Merge branch 'main' into dev

delete table creation
sqlite usage example
2026-01-03 20:12:25 +00:00 · 2025-08-04 15:13:55 +03:00 · 2025-08-04 13:38:27 +03:00 · 2025-08-04 13:36:38 +03:00 · 2025-08-04 13:36:30 +03:00 · 2025-08-04 13:36:21 +03:00
37 changed files with 1799 additions and 637 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -3,7 +3,10 @@ bin/
 cert/
 tmp/
 .meta/
+db/
+
+com/test.lua
+
 .vscode
 Taskfile.yml
-
 config.yaml
--- a/11
+++ b/11
@@ -30,7 +30,14 @@ build:
 	@# @echo "CGO_CFLAGS is: '$(CGO_CFLAGS)'"
 	@# @echo "CGO_LDFLAGS is: '$(CGO_LDFLAGS)'"
 	@# CGO_CFLAGS="$(CGO_CFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" 
-	go build -ldflags "$(LDFLAGS)" -o $(BIN_DIR)/$(APP_NAME) ./
+	@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!"
@@ -50,8 +57,10 @@ test:
 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/

 vet:
 	@go vet ./...
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -5,14 +5,12 @@ 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/internal/engine/config"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/logs"
 	"github.com/spf13/cobra"
 )

-var compositor *config.Compositor = config.NewCompositor()
-
 var rootCmd = &cobra.Command{
 	Use:   "node",
 	Short: "Go Sally node",
@@ -26,9 +24,9 @@ scripts in a given directory. For more information, visit: https://gosally.oblat

 func Execute() {
 	log.SetOutput(os.Stdout)
-	log.SetPrefix(logs.SetBrightBlack(fmt.Sprintf("(%s) ", corestate.StageNotReady)))
+	log.SetPrefix(colors.SetBrightBlack(fmt.Sprintf("(%s) ", corestate.StageNotReady)))
 	log.SetFlags(log.Ldate | log.Ltime)
-	compositor.LoadCMDLine(rootCmd)
+	hooks.Compositor.LoadCMDLine(rootCmd)
 	_ = rootCmd.Execute()
 	// if err := rootCmd.Execute(); err != nil {
 	// 	log.Fatalf("Unexpected error: %s", err.Error())
--- a/cmd/run.go
+++ b/cmd/run.go
@@ -1,349 +1,17 @@
 package cmd

 import (
-	"context"
-	"errors"
-	"fmt"
-	"io"
-	"io/fs"
-	"log"
-	"log/slog"
-	"net"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"syscall"
-	"time"
-
-	"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/sv1"
-	"github.com/go-chi/chi/v5"
-	"github.com/go-chi/cors"
+	"github.com/akyaiy/GoSally-mvp/hooks"
 	"github.com/spf13/cobra"
-	"golang.org/x/net/netutil"
-	"gopkg.in/ini.v1"
 )

-func contains(slice []string, item string) bool {
-	for _, v := range slice {
-		if v == item {
-			return true
-		}
-	}
-	return false
-}
-
 var runCmd = &cobra.Command{
 	Use:     "run",
 	Aliases: []string{"r"},
 	Short:   "Run node normally",
 	Long: `
 "run" starts the node with settings depending on the configuration file`,
-	Run: func(cmd *cobra.Command, args []string) {
-		nodeApp := app.New()
-
-		nodeApp.InitialHooks(
-			func(cs *corestate.CoreState, x *app.AppX) {
-				x.Config = compositor
-				x.Log.SetOutput(os.Stdout)
-				x.Log.SetPrefix(logs.SetBrightBlack(fmt.Sprintf("(%s) ", cs.Stage)))
-				x.Log.SetFlags(log.Ldate | log.Ltime)
-			},
-
-			// First stage: pre-init
-			func(cs *corestate.CoreState, x *app.AppX) {
-				*cs = *corestate.NewCorestate(&corestate.CoreState{
-					UUID32DirName:      "uuid",
-					NodeBinName:        filepath.Base(os.Args[0]),
-					NodeVersion:        config.NodeVersion,
-					MetaDir:            "./.meta",
-					Stage:              corestate.StagePreInit,
-					StartTimestampUnix: time.Now().Unix(),
-				})
-			},
-
-			func(cs *corestate.CoreState, x *app.AppX) {
-				x.Log.SetPrefix(logs.SetBlue(fmt.Sprintf("(%s) ", cs.Stage)))
-
-				if err := x.Config.LoadEnv(); err != nil {
-					x.Log.Fatalf("env load error: %s", err)
-				}
-				cs.NodePath = x.Config.Env.NodePath
-
-				if cfgPath := x.Config.CMDLine.Run.ConfigPath; cfgPath != "" {
-					x.Config.Env.ConfigPath = cfgPath
-				}
-				if err := x.Config.LoadConf(x.Config.Env.ConfigPath); err != nil {
-					x.Log.Fatalf("conf load error: %s", err)
-				}
-			},
-
-			func(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 {
-						x.Log.Fatalf("Cannod generate node uuid: %s", err.Error())
-					}
-					uuid32, err = corestate.GetNodeUUID(filepath.Join(cs.MetaDir, "uuid"))
-					if err != nil {
-						x.Log.Fatalf("Unexpected failure: %s", err.Error())
-					}
-				}
-				if err != nil {
-					x.Log.Fatalf("uuid load error: %s", err)
-				}
-				cs.UUID32 = uuid32
-			},
-
-			func(cs *corestate.CoreState, x *app.AppX) {
-				if x.Config.Env.ParentStagePID != os.Getpid() {
-					if !contains(x.Config.Conf.DisableWarnings, "--WNonStdTmpDir") && os.TempDir() != "/tmp" {
-						x.Log.Printf("%s: %s", logs.PrintWarn(), "Non-standard value specified for temporary directory")
-					}
-					// still pre-init stage
-					runDir, err := run_manager.Create(cs.UUID32)
-					if err != nil {
-						x.Log.Fatalf("Unexpected failure: %s", err.Error())
-					}
-					cs.RunDir = runDir
-					input, err := os.Open(os.Args[0])
-					if err != nil {
-						_ = run_manager.Clean()
-						x.Log.Fatalf("Unexpected failure: %s", err.Error())
-					}
-					if err := run_manager.Set(cs.NodeBinName); err != nil {
-						_ = run_manager.Clean()
-						x.Log.Fatalf("Unexpected failure: %s", err.Error())
-					}
-					fmgr := run_manager.File(cs.NodeBinName)
-					output, err := fmgr.Open()
-					if err != nil {
-						_ = run_manager.Clean()
-						x.Log.Fatalf("Unexpected failure: %s", err.Error())
-					}
-
-					if _, err := io.Copy(output, input); err != nil {
-						fmgr.Close()
-						_ = run_manager.Clean()
-						x.Log.Fatalf("Unexpected failure: %s", err.Error())
-					}
-					if err := os.Chmod(filepath.Join(cs.RunDir, cs.NodeBinName), 0755); err != nil {
-						fmgr.Close()
-						_ = run_manager.Clean()
-						x.Log.Fatalf("Unexpected failure: %s", err.Error())
-					}
-					input.Close()
-					fmgr.Close()
-					runArgs := os.Args
-					runArgs[0] = filepath.Join(cs.RunDir, cs.NodeBinName)
-
-					// prepare environ
-					env := utils.SetEviron(os.Environ(), fmt.Sprintf("GS_PARENT_PID=%d", os.Getpid()))
-
-					if err := syscall.Exec(runArgs[0], runArgs, env); err != nil {
-						_ = run_manager.Clean()
-						x.Log.Fatalf("Unexpected failure: %s", err.Error())
-					}
-				}
-				x.Log.Printf("Node uuid is %s", cs.UUID32)
-			},
-
-			// post-init stage
-			func(cs *corestate.CoreState, x *app.AppX) {
-				cs.Stage = corestate.StagePostInit
-				x.Log.SetPrefix(logs.SetYellow(fmt.Sprintf("(%s) ", cs.Stage)))
-
-				cs.RunDir = run_manager.Toggle()
-				exist, err := utils.ExistsMatchingDirs(filepath.Join(os.TempDir(), fmt.Sprintf("/*-%s-%s", cs.UUID32, "gosally-runtime")), cs.RunDir)
-				if err != nil {
-					_ = run_manager.Clean()
-					x.Log.Fatalf("Unexpected failure: %s", err.Error())
-				}
-				if exist {
-					_ = run_manager.Clean()
-					x.Log.Fatalf("Unable to continue node operation: A node with the same identifier was found in the runtime environment")
-				}
-
-				if err := run_manager.Set("run.lock"); err != nil {
-					_ = run_manager.Clean()
-					x.Log.Fatalf("Unexpected failure: %s", err.Error())
-				}
-				lockPath, err := run_manager.Get("run.lock")
-				if err != nil {
-					_ = run_manager.Clean()
-					x.Log.Fatalf("Unexpected failure: %s", err.Error())
-				}
-				lockFile := ini.Empty()
-				secRun, err := lockFile.NewSection("runtime")
-				if err != nil {
-					_ = run_manager.Clean()
-					x.Log.Fatalf("Unexpected failure: %s", err.Error())
-				}
-				secRun.Key("pid").SetValue(fmt.Sprintf("%d/%d", os.Getpid(), x.Config.Env.ParentStagePID))
-				secRun.Key("version").SetValue(cs.NodeVersion)
-				secRun.Key("uuid").SetValue(cs.UUID32)
-				secRun.Key("timestamp").SetValue(time.Unix(cs.StartTimestampUnix, 0).Format("2006-01-02/15:04:05 MST"))
-				secRun.Key("timestamp-unix").SetValue(fmt.Sprintf("%d", cs.StartTimestampUnix))
-
-				err = lockFile.SaveTo(lockPath)
-				if err != nil {
-					_ = run_manager.Clean()
-					x.Log.Fatalf("Unexpected failure: %s", err.Error())
-				}
-			},
-
-			func(cs *corestate.CoreState, x *app.AppX) {
-				cs.Stage = corestate.StageReady
-				x.Log.SetPrefix(logs.SetGreen(fmt.Sprintf("(%s) ", cs.Stage)))
-
-				x.SLog = new(slog.Logger)
-				newSlog, err := logs.SetupLogger(x.Config.Conf.Log)
-				if err != nil {
-					_ = run_manager.Clean()
-					x.Log.Fatalf("Unexpected failure: %s", err.Error())
-				}
-				*x.SLog = *newSlog
-			},
-		)
-
-		nodeApp.Run(func(ctx context.Context, cs *corestate.CoreState, x *app.AppX) error {
-			ctxMain, cancelMain := context.WithCancel(ctx)
-			runLockFile := run_manager.File("run.lock")
-			_, err := runLockFile.Open()
-			if err != nil {
-				x.Log.Fatalf("cannot open run.lock: %s", err)
-			}
-
-			_, err = runLockFile.Watch(ctxMain, func() {
-				x.Log.Printf("run.lock was touched")
-				_ = run_manager.Clean()
-				cancelMain()
-			})
-			if err != nil {
-				x.Log.Printf("watch error: %s", err)
-			}
-
-			serverv1 := sv1.InitV1Server(&sv1.HandlerV1InitStruct{
-				X:          x,
-				CS:         cs,
-				AllowedCmd: regexp.MustCompile(`^[a-zA-Z0-9]+(>[a-zA-Z0-9]+)*$`),
-				Ver:        "v1",
-			})
-
-			s := gateway.InitGateway(&gateway.GatewayServerInit{
-				CS: cs,
-				X:  x,
-			}, serverv1)
-
-			r := chi.NewRouter()
-			r.Use(cors.Handler(cors.Options{
-				AllowedOrigins:   []string{"*"},
-				AllowedMethods:   []string{"GET", "POST", "OPTIONS"},
-				AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
-				AllowCredentials: true,
-				MaxAge:           300,
-			}))
-			r.HandleFunc(config.ComDirRoute, s.Handle)
-			r.Route("/favicon.ico", func(r chi.Router) {
-				r.Get("/", func(w http.ResponseWriter, r *http.Request) {
-					w.WriteHeader(http.StatusNoContent)
-				})
-			})
-
-			srv := &http.Server{
-				Addr:    x.Config.Conf.HTTPServer.Address,
-				Handler: r,
-				ErrorLog: log.New(&logs.SlogWriter{
-					Logger: x.SLog,
-					Level:  logs.GlobalLevel,
-				}, "", 0),
-			}
-
-			nodeApp.Fallback(func(ctx context.Context, cs *corestate.CoreState, x *app.AppX) {
-				if err := srv.Shutdown(ctxMain); err != nil {
-					x.Log.Printf("%s: Failed to stop the server gracefully: %s", logs.PrintError(), err.Error())
-				} else {
-					x.Log.Printf("Server stopped gracefully")
-				}
-
-				x.Log.Println("Cleaning up...")
-
-				if err := run_manager.Clean(); err != nil {
-					x.Log.Printf("%s: Cleanup error: %s", logs.PrintError(), err.Error())
-				}
-				x.Log.Println("bye!")
-			})
-
-			go func() {
-				defer utils.CatchPanicWithCancel(cancelMain)
-				if x.Config.Conf.TLS.TlsEnabled {
-					listener, err := net.Listen("tcp", fmt.Sprintf("%s:%s", x.Config.Conf.HTTPServer.Address, x.Config.Conf.HTTPServer.Port))
-					if err != nil {
-						x.Log.Printf("%s: Failed to start TLS listener: %s", logs.PrintError(), err.Error())
-						cancelMain()
-						return
-					}
-					x.Log.Printf("Serving on %s port %s with TLS... (https://%s%s)", x.Config.Conf.HTTPServer.Address, x.Config.Conf.HTTPServer.Port, fmt.Sprintf("%s:%s", x.Config.Conf.HTTPServer.Address, x.Config.Conf.HTTPServer.Port), config.ComDirRoute)
-					limitedListener := netutil.LimitListener(listener, 100)
-					if err := srv.ServeTLS(limitedListener, x.Config.Conf.TLS.CertFile, x.Config.Conf.TLS.KeyFile); err != nil && !errors.Is(err, http.ErrServerClosed) {
-						x.Log.Printf("%s: Failed to start HTTPS server: %s", logs.PrintError(), err.Error())
-						cancelMain()
-					}
-				} else {
-					x.Log.Printf("Serving on %s port %s... (http://%s%s)", x.Config.Conf.HTTPServer.Address, x.Config.Conf.HTTPServer.Port, fmt.Sprintf("%s:%s", x.Config.Conf.HTTPServer.Address, x.Config.Conf.HTTPServer.Port), config.ComDirRoute)
-					listener, err := net.Listen("tcp", fmt.Sprintf("%s:%s", x.Config.Conf.HTTPServer.Address, x.Config.Conf.HTTPServer.Port))
-					if err != nil {
-						x.Log.Printf("%s: Failed to start listener: %s", logs.PrintError(), err.Error())
-						cancelMain()
-						return
-					}
-					limitedListener := netutil.LimitListener(listener, 100)
-					if err := srv.Serve(limitedListener); err != nil && !errors.Is(err, http.ErrServerClosed) {
-						x.Log.Printf("%s: Failed to start HTTP server: %s", logs.PrintError(), err.Error())
-						cancelMain()
-					}
-				}
-			}()
-
-			if x.Config.Conf.Updates.UpdatesEnabled {
-				go func() {
-					defer utils.CatchPanicWithCancel(cancelMain)
-					updated := update.NewUpdater(&update.UpdaterInit{
-						X:      x,
-						Ctx:    ctxMain,
-						Cancel: cancelMain,
-					})
-					updated.Shutdownfunc(cancelMain)
-					for {
-						isNewUpdate, err := updated.CkeckUpdates()
-						if err != nil {
-							x.Log.Printf("Failed to check for updates: %s", err.Error())
-						}
-						if isNewUpdate {
-							if err := updated.Update(); err != nil {
-								x.Log.Printf("Failed to update: %s", err.Error())
-							} else {
-								x.Log.Printf("Update completed successfully")
-							}
-						}
-						time.Sleep(x.Config.Conf.Updates.CheckInterval)
-					}
-				}()
-			}
-
-			<-ctxMain.Done()
-			nodeApp.CallFallback(ctx)
-			return nil
-		})
-	},
+	Run: hooks.Run,
 }

 func init() {
--- a/com/DB/Put.lua
+++ b/com/DB/Put.lua
@@ -0,0 +1,66 @@
+---@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()
--- a/com/List.lua
+++ b/com/List.lua
@@ -1,6 +1,18 @@
 -- com/List.lua

-local function isValidCommand(name)
+local session = require("internal.session")
+
+if session.request and session.request.params and session.request.params.about then
+  session.response.result = {
+    description = "Returns a list of available methods",
+    params = {
+      layer = "select which layer list to display"
+    }
+  }
+  return
+end
+
+local function isValidName(name)
  return name:match("^[%w]+$") ~= nil
 end

@@ -11,8 +23,20 @@ local function scanDirectory(basePath, targetPath)

  if handle then
    for filePath in handle:lines() do
-      local fileName = filePath:match("([^/]+)%.lua$")
-      if fileName and isValidCommand(fileName) then
+      local parts = {}
+      for part in filePath:gsub(".lua$", ""):gmatch("[^/]+") do
+        table.insert(parts, part)
+      end
+
+      local allValid = true
+      for _, part in ipairs(parts) do
+        if not isValidName(part) then
+          allValid = false
+          break
+        end
+      end
+
+      if allValid then
        local relPath = filePath:gsub("^"..basePath.."/", ""):gsub(".lua$", ""):gsub("/", ">")
        table.insert(res, relPath)
      end
@@ -24,8 +48,8 @@ local function scanDirectory(basePath, targetPath)
 end

 local basePath = "com"
-local layer = In.Params and In.Params.layer and In.Params.layer:gsub(">", "/") or nil
+local layer = session.request and session.request.params.layer and session.request.params.layer:gsub(">", "/") or nil

-Out.Result = {
+session.response.result = {
  answer = layer and scanDirectory(basePath, layer) or scanDirectory(basePath, "")
 }
--- a/com/Net/GetExpl.lua
+++ b/com/Net/GetExpl.lua
@@ -0,0 +1,29 @@
+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"
+}
+
--- a/com/Net/PostExpl.lua
+++ b/com/Net/PostExpl.lua
@@ -0,0 +1,35 @@
+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"
+}
--- a/com/Utils/Echo.lua
+++ b/com/Utils/Echo.lua
@@ -1,4 +1,14 @@
-function validate()
+if In.Params and In.Params.about then
+  Out.Result = {
+    description = "Echo of the message",
+    params = {
+      msg = "just message"
+    }
+  }
+  return
+end
+
+local function validate()
 	if not In.Params.msg or In.Params.msg == "" then
 		Out.Error = {
 			message = "there must be a msg parameter"
--- a/com/Utils/Ping.lua
+++ b/com/Utils/Ping.lua
@@ -1,7 +1,8 @@
-Log.Event("got ping")
-Log.EventWarn("got ping")
-Log.EventError("got ping")
-
-Log.Error("mm")
+if In.Params and In.Params.about then
+  Out.Result = {
+    description = "Just ping"
+  }
+  return
+end

 Out.Result.answer = "pong"
--- a/com/_globals.lua
+++ b/com/_globals.lua
@@ -1,24 +1,54 @@
---@diagnostic disable: missing-fields, missing-return
---@alias AnyTable table<string, any>
+--@diagnostic disable: missing-fields, missing-return

---@type AnyTable
-In = {
-	Params = {},
-}
+---@alias Any any
+---@alias AnyTable table<string, Any>

---@type AnyTable
-Out = {
-	Result = {},
-}
+--- Global session module interface
+---@class SessionIn
+---@field params AnyTable Request parameters

---@class Log
---@field Info fun(msg: string)
---@field Debug fun(msg: string)
---@field Error fun(msg: string)
---@field Warn fun(msg: string)
---@field Event fun(msg: string)
---@field EventError fun(msg: string)
---@field EventWarn fun(msg: string)
+---@class SessionOut
+---@field result Any|string? Result payload (table or primitive)
+---@field error { code: integer, message: string, data: Any }? Optional error info

---@type Log
-Log = {}
+---@class SessionModule
+---@field request SessionIn Input context (read-only)
+---@field response SessionOut Output context (write results/errors)
+
+--- Global log module interface
+---@class LogModule
+---@field info fun(msg: string) Log informational message
+---@field debug fun(msg: string) Log debug message
+---@field error fun(msg: string) Log error message
+---@field warn fun(msg: string) Log warning message
+---@field event fun(msg: string) Log event (generic)
+---@field event_error fun(msg: string) Log event error
+---@field event_warn fun(msg: string) Log event warning
+
+--- Global net module interface
+---@class HttpResponse
+---@field status integer HTTP status code
+---@field status_text string HTTP status text
+---@field body string Response body
+---@field content_length integer Content length
+---@field headers AnyTable Map of headers
+
+---@class HttpModule
+---@field get fun(log: boolean, url: string): HttpResponse, string? Perform GET
+---@field post fun(log: boolean, url: string, content_type: string, payload: string): HttpResponse, string? Perform POST
+
+---@class NetModule
+---@field http HttpModule HTTP client functions
+
+--- Global variables declaration
+---@global
+---@type SessionModule
+_G.session = session or {}
+
+---@global
+---@type LogModule
+_G.log = log or {}
+
+---@global
+---@type NetModule
+_G.net = net or {}
--- a/config-example.yaml
+++ b/config-example.yaml
@@ -1,21 +1,30 @@
-mode: "prod"
+node:
+  mode: dev
+  name: "My gosally node"
+  show_config: true
+  com_dir: "%path%/com"

 http_server:
-  address: "0.0.0.0:8080"
-  api:
-    latest-version: v1
-    layers:
-      - b1
-      - s2
+  address: "0.0.0.0"
+  port: "8080"
+  session_ttl: 5s
+  timeout: 3s
+  idle_timeout: 30s

 tls:
-  enabled: false
-  cert_file: "./cert/fullchain.pem"
-  key_file: "./cert/privkey.pem"
-
-com_dir: "com/"
+  enabled: true
+  cert_file: "%path%/cert/fullchain.pem"
+  key_file: "%path%/cert/privkey.pem"

 updates:
-  enabled: true
+  enabled: false
  check-interval: 1h
  repository_url: "https://repo.serve.lv/raw/go-sally"
+
+log:
+  json_format: false
+  level: "debug"
+
+disable_warnings:
+  - --WNonStdTmpDir
+  - --WUndefLogLevel
--- a/db/users.db
+++ b/db/users.db
--- a/go.mod
+++ b/go.mod
@@ -4,6 +4,7 @@ go 1.24.4

 require (
 	github.com/go-chi/chi/v5 v5.2.2
+	github.com/google/uuid v1.6.0
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/viper v1.20.1
 	github.com/yuin/gopher-lua v1.1.1
@@ -17,7 +18,6 @@ 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/google/uuid v1.6.0 // indirect
 	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
@@ -29,7 +29,6 @@ require (
 	github.com/spf13/cast v1.9.2 // indirect
 	github.com/spf13/pflag v1.0.7 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
-	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/exp v0.0.0-20250718183923-645b1fa84792 // indirect
 	golang.org/x/sys v0.34.0 // indirect
 	golang.org/x/text v0.27.0 // indirect
--- a/go.sum
+++ b/go.sum
@@ -15,6 +15,8 @@ github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9L
 github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 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=
+github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
@@ -36,12 +38,8 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq
 github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sagikazarmark/locafero v0.9.0 h1:GbgQGNtTrEmddYDSAH9QLRyfAHY12md+8YFTqyMTC9k=
-github.com/sagikazarmark/locafero v0.9.0/go.mod h1:UBUyz37V+EdMS3hDF3QWIiVr/2dPrx49OMO0Bn0hJqk=
 github.com/sagikazarmark/locafero v0.10.0 h1:FM8Cv6j2KqIhM2ZK7HZjm4mpj9NBktLgowT1aN9q5Cc=
 github.com/sagikazarmark/locafero v0.10.0/go.mod h1:Ieo3EUsjifvQu4NZwV5sPd4dwvu0OCgEQV7vjc9yDjw=
-github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
-github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
 github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
 github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
 github.com/spf13/afero v1.14.0 h1:9tH6MapGnn/j0eb0yIXiLjERO8RB6xIVZRDCX7PtqWA=
@@ -61,17 +59,21 @@ github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
 github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
-go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
-go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 golang.org/x/exp v0.0.0-20250718183923-645b1fa84792 h1:R9PFI6EUdfVKgwKjZef7QIwGcBKu86OEFpJ9nUEP2l4=
 golang.org/x/exp v0.0.0-20250718183923-645b1fa84792/go.mod h1:A+z0yzpGtvnG90cToK5n2tu8UJVP2XUATh+r+sfOOOc=
+golang.org/x/mod v0.26.0 h1:EGMPT//Ezu+ylkCijjPc+f4Aih7sZvaAr+O3EHBxvZg=
+golang.org/x/mod v0.26.0/go.mod h1:/j6NAhSk8iQ723BGAUyoAcn7SlD7s15Dp9Nd/SfeaFQ=
 golang.org/x/net v0.42.0 h1:jzkYrhi3YQWD6MLBJcsklgQsoAcw89EcZbJw8Z614hs=
 golang.org/x/net v0.42.0/go.mod h1:FF1RA5d3u7nAYA4z2TkclSCKh68eSXtiFwcWQpPXdt8=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
 golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.27.0 h1:4fGWRpyh641NLlecmyl4LOe6yDdfaYNrGb2zdfo4JV4=
 golang.org/x/text v0.27.0/go.mod h1:1D28KMCvyooCX9hBiosv5Tz/+YLxj0j7XhWjpSUF7CU=
+golang.org/x/tools v0.35.0 h1:mBffYraMEf7aa0sB+NuKnuCy8qI/9Bughn8dC2Gu5r0=
+golang.org/x/tools v0.35.0/go.mod h1:NKdj5HkL/73byiZSJjqJgKn3ep7KjFkBOkR/Hps3VPw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -81,11 +83,29 @@ gopkg.in/natefinch/lumberjack.v2 v2.2.1 h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST
 gopkg.in/natefinch/lumberjack.v2 v2.2.1/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+modernc.org/cc/v4 v4.26.3 h1:yEN8dzrkRFnn4PUUKXLYIqVf2PJYAEjMTFjO3BDGc3I=
+modernc.org/cc/v4 v4.26.3/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
+modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=
+modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=
+modernc.org/fileutil v1.3.8 h1:qtzNm7ED75pd1C7WgAGcK4edm4fvhtBsEiI/0NQ54YM=
+modernc.org/fileutil v1.3.8/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
+modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
+modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
+modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
+modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
 modernc.org/libc v1.66.6 h1:RyQpwAhM/19nXD8y3iejM/AjmKwY2TjxZTlUWTsWw2U=
 modernc.org/libc v1.66.6/go.mod h1:j8z0EYAuumoMQ3+cWXtmw6m+LYn3qm8dcZDFtFTSq+M=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
 modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
+modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
+modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
+modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
+modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
 modernc.org/sqlite v1.38.2 h1:Aclu7+tgjgcQVShZqim41Bbw9Cho0y/7WzYptXqkEek=
 modernc.org/sqlite v1.38.2/go.mod h1:cPTJYSlgg3Sfg046yBShXENNtPrWrDX8bsbAQBzgQ5E=
+modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
+modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
+modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
+modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
--- a/hooks/initial.go
+++ b/hooks/initial.go
@@ -0,0 +1,403 @@
+package hooks
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"log/slog"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"reflect"
+	"slices"
+	"strings"
+	"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"
+	"gopkg.in/ini.v1"
+)
+
+var Compositor *config.Compositor = config.NewCompositor()
+
+func InitGlobalLoggerHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	x.Config = Compositor
+	x.Log.SetOutput(os.Stdout)
+	x.Log.SetPrefix(colors.SetBrightBlack(fmt.Sprintf("(%s) ", cs.Stage)))
+	x.Log.SetFlags(log.Ldate | log.Ltime)
+}
+
+// First stage: pre-init
+func InitCorestateHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	*cs = *corestate.NewCorestate(&corestate.CoreState{
+		UUID32DirName:      "uuid",
+		NodeBinName:        filepath.Base(os.Args[0]),
+		NodeVersion:        config.NodeVersion,
+		MetaDir:            "./.meta",
+		Stage:              corestate.StagePreInit,
+		StartTimestampUnix: time.Now().Unix(),
+	})
+}
+
+func InitConfigLoadHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	x.Log.SetPrefix(colors.SetYellow(fmt.Sprintf("(%s) ", cs.Stage)))
+
+	if err := x.Config.LoadEnv(); err != nil {
+		x.Log.Fatalf("env load error: %s", err)
+	}
+	cs.NodePath = *x.Config.Env.NodePath
+
+	if cfgPath := x.Config.CMDLine.Run.ConfigPath; cfgPath != "" {
+		x.Config.Env.ConfigPath = &cfgPath
+	}
+	if err := x.Config.LoadConf(*x.Config.Env.ConfigPath); err != nil {
+		x.Log.Fatalf("conf load error: %s", err)
+	}
+}
+
+func InitUUUDHook(_ 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 {
+			x.Log.Fatalf("Cannod generate node uuid: %s", err.Error())
+		}
+		uuid32, err = corestate.GetNodeUUID(filepath.Join(cs.MetaDir, "uuid"))
+		if err != nil {
+			x.Log.Fatalf("Unexpected failure: %s", err.Error())
+		}
+	}
+	if err != nil {
+		x.Log.Fatalf("uuid load error: %s", err)
+	}
+	cs.UUID32 = uuid32
+}
+
+func InitRuntimeHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	if *x.Config.Env.ParentStagePID != os.Getpid() {
+		// still pre-init stage
+		runDir, err := run_manager.Create(cs.UUID32)
+		if err != nil {
+			x.Log.Fatalf("Unexpected failure: %s", err.Error())
+		}
+		cs.RunDir = runDir
+		input, err := os.Open(os.Args[0])
+		if err != nil {
+			_ = run_manager.Clean()
+			x.Log.Fatalf("Unexpected failure: %s", err.Error())
+		}
+		if err := run_manager.Set(cs.NodeBinName); err != nil {
+			_ = run_manager.Clean()
+			x.Log.Fatalf("Unexpected failure: %s", err.Error())
+		}
+		fmgr := run_manager.File(cs.NodeBinName)
+		output, err := fmgr.Open()
+		if err != nil {
+			_ = run_manager.Clean()
+			x.Log.Fatalf("Unexpected failure: %s", err.Error())
+		}
+
+		if _, err := io.Copy(output, input); err != nil {
+			fmgr.Close()
+			_ = run_manager.Clean()
+			x.Log.Fatalf("Unexpected failure: %s", err.Error())
+		}
+		if err := os.Chmod(filepath.Join(cs.RunDir, cs.NodeBinName), 0755); err != nil {
+			fmgr.Close()
+			_ = run_manager.Clean()
+			x.Log.Fatalf("Unexpected failure: %s", err.Error())
+		}
+		input.Close()
+		fmgr.Close()
+		runArgs := os.Args
+		runArgs[0] = filepath.Join(cs.RunDir, cs.NodeBinName)
+
+		// prepare environ
+		env := utils.SetEviron(os.Environ(), fmt.Sprintf("GS_PARENT_PID=%d", os.Getpid()))
+
+		if err := syscall.Exec(runArgs[0], runArgs, env); err != nil {
+			_ = run_manager.Clean()
+			x.Log.Fatalf("Unexpected failure: %s", err.Error())
+		}
+	}
+	x.Log.Printf("Node uuid is %s", cs.UUID32)
+}
+
+// post-init stage
+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...")
+
+		if err := run_manager.Clean(); err != nil {
+			x.Log.Printf("%s: Cleanup error: %s", colors.PrintError(), err.Error())
+		}
+		x.Log.Println("bye!")
+	})
+
+	cs.Stage = corestate.StagePostInit
+	x.Log.SetPrefix(colors.SetBlue(fmt.Sprintf("(%s) ", cs.Stage)))
+
+	cs.RunDir = run_manager.Toggle()
+	exist, err := utils.ExistsMatchingDirs(filepath.Join(os.TempDir(), fmt.Sprintf("/*-%s-%s", cs.UUID32, "gosally-runtime")), cs.RunDir)
+	if err != nil {
+		_ = run_manager.Clean()
+		x.Log.Fatalf("Unexpected failure: %s", err.Error())
+	}
+	if exist {
+		_ = run_manager.Clean()
+		x.Log.Fatalf("Unable to continue node operation: A node with the same identifier was found in the runtime environment")
+	}
+
+	if err := run_manager.Set("run.lock"); err != nil {
+		_ = run_manager.Clean()
+		x.Log.Fatalf("Unexpected failure: %s", err.Error())
+	}
+	lockPath, err := run_manager.Get("run.lock")
+	if err != nil {
+		_ = run_manager.Clean()
+		x.Log.Fatalf("Unexpected failure: %s", err.Error())
+	}
+	lockFile := ini.Empty()
+	secRun, err := lockFile.NewSection("runtime")
+	if err != nil {
+		_ = run_manager.Clean()
+		x.Log.Fatalf("Unexpected failure: %s", err.Error())
+	}
+	secRun.Key("pid").SetValue(fmt.Sprintf("%d/%d", os.Getpid(), x.Config.Env.ParentStagePID))
+	secRun.Key("version").SetValue(cs.NodeVersion)
+	secRun.Key("uuid").SetValue(cs.UUID32)
+	secRun.Key("timestamp").SetValue(time.Unix(cs.StartTimestampUnix, 0).Format("2006-01-02/15:04:05 MST"))
+	secRun.Key("timestamp-unix").SetValue(fmt.Sprintf("%d", cs.StartTimestampUnix))
+
+	err = lockFile.SaveTo(lockPath)
+	if err != nil {
+		_ = run_manager.Clean()
+		x.Log.Fatalf("Unexpected failure: %s", err.Error())
+	}
+}
+
+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")
+	}
+
+	replacements := map[string]any{
+		"%tmp%":    filepath.Clean(run_manager.RuntimeDir()),
+		"%path%":   *x.Config.Env.NodePath,
+		"%stdout%": "_1STDout",
+		"%stderr%": "_2STDerr",
+		"%1%":      "_1STDout",
+		"%2%":      "_2STDerr",
+	}
+
+	processConfig(&x.Config.Conf, replacements)
+
+	if !slices.Contains(logs.Levels.Available, *x.Config.Conf.Log.Level) {
+		if !slices.Contains(*x.Config.Conf.DisableWarnings, "--WUndefLogLevel") {
+			x.Log.Printf("%s: %s", colors.PrintWarn(), fmt.Sprintf("Unknown logging level %s, fallback level: %s", *x.Config.Conf.Log.Level, logs.Levels.Fallback))
+		}
+		x.Config.Conf.Log.Level = &logs.Levels.Fallback
+	}
+}
+
+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)
+		x.Config.Print(x.Config.Conf)
+
+		fmt.Printf("Environment:\n")
+		x.Config.Print(x.Config.Env)
+
+		if cs.UUID32 != "" && !askConfirm("Is that ok?", true) {
+			x.Log.Printf("Cancel launch")
+			NodeApp.CallFallback(ctx)
+		}
+	}
+
+	x.Log.Printf("Starting \"%s\" node", *x.Config.Conf.Node.Name)
+}
+
+func InitSLogHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	cs.Stage = corestate.StageReady
+	x.Log.SetPrefix(colors.SetGreen(fmt.Sprintf("(%s) ", cs.Stage)))
+
+	x.SLog = new(slog.Logger)
+	newSlog, err := logs.SetupLogger(x.Config.Conf.Log)
+	if err != nil {
+		_ = run_manager.Clean()
+		x.Log.Fatalf("Unexpected failure: %s", err.Error())
+	}
+	*x.SLog = *newSlog
+}
+
+func processConfig(conf any, replacements map[string]any) error {
+	val := reflect.ValueOf(conf)
+	if val.Kind() == reflect.Ptr {
+		val = val.Elem()
+	}
+
+	switch val.Kind() {
+	case reflect.Struct:
+		for i := 0; i < val.NumField(); i++ {
+			field := val.Field(i)
+			if field.CanAddr() && field.CanSet() {
+				if err := processConfig(field.Addr().Interface(), replacements); err != nil {
+					return err
+				}
+			}
+		}
+
+	case reflect.Slice:
+		for i := 0; i < val.Len(); i++ {
+			elem := val.Index(i)
+			if elem.CanAddr() && elem.CanSet() {
+				if err := processConfig(elem.Addr().Interface(), replacements); err != nil {
+					return err
+				}
+			}
+		}
+
+	case reflect.Map:
+		for _, key := range val.MapKeys() {
+			elem := val.MapIndex(key)
+			if elem.CanInterface() {
+				newVal := reflect.New(elem.Type()).Elem()
+				newVal.Set(elem)
+
+				if err := processConfig(newVal.Addr().Interface(), replacements); err != nil {
+					return err
+				}
+
+				val.SetMapIndex(key, newVal)
+			}
+		}
+
+	case reflect.String:
+		str := val.String()
+
+		if replacement, exists := replacements[str]; exists {
+			if err := setValue(val, replacement); err != nil {
+				return fmt.Errorf("failed to set %q: %v", str, err)
+			}
+		} else {
+			for placeholder, replacement := range replacements {
+				if strings.Contains(str, placeholder) {
+					replacementStr, err := toString(replacement)
+					if err != nil {
+						return fmt.Errorf("invalid replacement for %q: %v", placeholder, err)
+					}
+					newStr := strings.ReplaceAll(str, placeholder, replacementStr)
+					val.SetString(newStr)
+				}
+			}
+		}
+
+	case reflect.Ptr:
+		if !val.IsNil() {
+			elem := val.Elem()
+			if elem.Kind() == reflect.String {
+				str := elem.String()
+				if replacement, exists := replacements[str]; exists {
+					strVal, err := toString(replacement)
+					if err != nil {
+						return fmt.Errorf("cannot convert replacement to string: %v", err)
+					}
+					elem.SetString(strVal)
+				} else {
+					for placeholder, replacement := range replacements {
+						if strings.Contains(str, placeholder) {
+							replacementStr, err := toString(replacement)
+							if err != nil {
+								return fmt.Errorf("invalid replacement for %q: %v", placeholder, err)
+							}
+							newStr := strings.ReplaceAll(str, placeholder, replacementStr)
+							elem.SetString(newStr)
+						}
+					}
+				}
+			} else {
+				return processConfig(elem.Addr().Interface(), replacements)
+			}
+		}
+	}
+	return nil
+}
+
+func setValue(val reflect.Value, replacement any) error {
+	if !val.CanSet() {
+		return fmt.Errorf("value is not settable")
+	}
+
+	replacementVal := reflect.ValueOf(replacement)
+	if replacementVal.Type().AssignableTo(val.Type()) {
+		val.Set(replacementVal)
+		return nil
+	}
+
+	if val.Kind() == reflect.String {
+		str, err := toString(replacement)
+		if err != nil {
+			return fmt.Errorf("cannot convert replacement to string: %v", err)
+		}
+		val.SetString(str)
+		return nil
+	}
+
+	return fmt.Errorf("type mismatch: cannot assign %T to %v", replacement, val.Type())
+}
+
+func toString(v any) (string, error) {
+	switch s := v.(type) {
+	case string:
+		return s, nil
+	case fmt.Stringer:
+		return s.String(), nil
+	default:
+		return fmt.Sprint(v), nil
+	}
+}
+
+func askConfirm(prompt string, defaultYes bool) bool {
+	ctx, _ := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+
+	fmt.Print(prompt)
+	if defaultYes {
+		fmt.Printf(" (%s/%s): ", colors.SetBrightGreen("Y"), colors.SetBrightRed("n"))
+	} else {
+		fmt.Printf(" (%s/%s): ", colors.SetBrightGreen("n"), colors.SetBrightRed("Y"))
+	}
+
+	inputChan := make(chan string, 1)
+
+	go func() {
+		reader := bufio.NewReader(os.Stdin)
+		text, _ := reader.ReadString('\n')
+		inputChan <- text
+	}()
+
+	select {
+	case <-ctx.Done():
+		fmt.Println("")
+		NodeApp.CallFallback(ctx)
+		os.Exit(3)
+	case text := <-inputChan:
+		text = strings.TrimSpace(strings.ToLower(text))
+		if text == "" {
+			return defaultYes
+		}
+		if text == "y" || text == "yes" {
+			return true
+		}
+		return false
+	}
+	return defaultYes
+}
--- a/hooks/run.go
+++ b/hooks/run.go
@@ -0,0 +1,176 @@
+package hooks
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"log"
+	"log/slog"
+	"net"
+	"net/http"
+	"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/go-chi/chi/v5"
+	"github.com/go-chi/cors"
+	"github.com/spf13/cobra"
+	"golang.org/x/net/netutil"
+)
+
+var NodeApp = app.New()
+
+func Run(cmd *cobra.Command, args []string) {
+	NodeApp.InitialHooks(
+		InitGlobalLoggerHook, InitCorestateHook, InitConfigLoadHook,
+		InitUUUDHook, InitRuntimeHook, InitRunlockHook,
+		InitConfigReplHook, InitConfigPrintHook, InitSLogHook,
+	)
+
+	NodeApp.Run(RunHook)
+}
+
+func RunHook(ctx context.Context, cs *corestate.CoreState, x *app.AppX) error {
+	ctxMain, cancelMain := context.WithCancel(ctx)
+	runLockFile := run_manager.File("run.lock")
+	_, err := runLockFile.Open()
+	if err != nil {
+		x.Log.Fatalf("cannot open run.lock: %s", err)
+	}
+
+	_, err = runLockFile.Watch(ctxMain, func() {
+		x.Log.Printf("run.lock was touched")
+		_ = run_manager.Clean()
+		cancelMain()
+	})
+	if err != nil {
+		x.Log.Printf("watch error: %s", err)
+	}
+
+	serverv1 := sv1.InitV1Server(&sv1.HandlerV1InitStruct{
+		X:          x,
+		CS:         cs,
+		AllowedCmd: regexp.MustCompile(`^[a-zA-Z0-9]+(>[a-zA-Z0-9]+)*$`),
+		Ver:        "v1",
+	})
+
+	session_manager := session.New(*x.Config.Conf.HTTPServer.SessionTTL)
+
+	s := gateway.InitGateway(&gateway.GatewayServerInit{
+		SM: session_manager,
+		CS: cs,
+		X:  x,
+	}, serverv1)
+
+	r := chi.NewRouter()
+	r.Use(cors.Handler(cors.Options{
+		AllowedOrigins:   []string{"*"},
+		AllowedMethods:   []string{"POST"},
+		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token", "X-Session-UUID"},
+		AllowCredentials: true,
+		MaxAge:           300,
+	}))
+	r.HandleFunc(config.ComDirRoute, s.Handle)
+	r.Route("/favicon.ico", func(r chi.Router) {
+		r.Get("/", func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusNoContent)
+		})
+	})
+
+	srv := &http.Server{
+		Addr:    *x.Config.Conf.HTTPServer.Address,
+		Handler: r,
+		ErrorLog: log.New(&logs.SlogWriter{
+			Logger: x.SLog,
+			Level:  slog.LevelError,
+		}, "", 0),
+	}
+
+	NodeApp.Fallback(func(ctx context.Context, cs *corestate.CoreState, x *app.AppX) {
+		if err := srv.Shutdown(ctxMain); err != nil {
+			x.Log.Printf("%s: Failed to stop the server gracefully: %s", colors.PrintError(), err.Error())
+		} else {
+			x.Log.Printf("Server stopped gracefully")
+		}
+
+		x.Log.Println("Cleaning up...")
+
+		if err := run_manager.Clean(); err != nil {
+			x.Log.Printf("%s: Cleanup error: %s", colors.PrintError(), err.Error())
+		}
+		x.Log.Println("bye!")
+	})
+
+	go func() {
+		defer utils.CatchPanicWithCancel(cancelMain)
+		if *x.Config.Conf.TLS.TlsEnabled {
+			listener, err := net.Listen("tcp", fmt.Sprintf("%s:%s", *x.Config.Conf.HTTPServer.Address, *x.Config.Conf.HTTPServer.Port))
+			if err != nil {
+				x.Log.Printf("%s: Failed to start TLS listener: %s", colors.PrintError(), err.Error())
+				cancelMain()
+				return
+			}
+			x.Log.Printf("Serving on %s port %s with TLS... (https://%s%s)", *x.Config.Conf.HTTPServer.Address, *x.Config.Conf.HTTPServer.Port, fmt.Sprintf("%s:%s", *x.Config.Conf.HTTPServer.Address, *x.Config.Conf.HTTPServer.Port), config.ComDirRoute)
+			limitedListener := netutil.LimitListener(listener, 100)
+			if err := srv.ServeTLS(limitedListener, *x.Config.Conf.TLS.CertFile, *x.Config.Conf.TLS.KeyFile); err != nil && !errors.Is(err, http.ErrServerClosed) {
+				x.Log.Printf("%s: Failed to start HTTPS server: %s", colors.PrintError(), err.Error())
+				cancelMain()
+			}
+		} else {
+			x.Log.Printf("Serving on %s port %s... (http://%s%s)", *x.Config.Conf.HTTPServer.Address, *x.Config.Conf.HTTPServer.Port, fmt.Sprintf("%s:%s", *x.Config.Conf.HTTPServer.Address, *x.Config.Conf.HTTPServer.Port), config.ComDirRoute)
+			listener, err := net.Listen("tcp", fmt.Sprintf("%s:%s", *x.Config.Conf.HTTPServer.Address, *x.Config.Conf.HTTPServer.Port))
+			if err != nil {
+				x.Log.Printf("%s: Failed to start listener: %s", colors.PrintError(), err.Error())
+				cancelMain()
+				return
+			}
+			limitedListener := netutil.LimitListener(listener, 100)
+			if err := srv.Serve(limitedListener); err != nil && !errors.Is(err, http.ErrServerClosed) {
+				x.Log.Printf("%s: Failed to start HTTP server: %s", colors.PrintError(), err.Error())
+				cancelMain()
+			}
+		}
+	}()
+
+	session_manager.StartCleanup(5 * time.Second)
+
+	if *x.Config.Conf.Updates.UpdatesEnabled {
+		go func() {
+			defer utils.CatchPanicWithCancel(cancelMain)
+			updated := update.NewUpdater(&update.UpdaterInit{
+				X:      x,
+				Ctx:    ctxMain,
+				Cancel: cancelMain,
+			})
+			updated.Shutdownfunc(cancelMain)
+			for {
+				isNewUpdate, err := updated.CkeckUpdates()
+				if err != nil {
+					x.Log.Printf("Failed to check for updates: %s", err.Error())
+				}
+				if isNewUpdate {
+					if err := updated.Update(); err != nil {
+						x.Log.Printf("Failed to update: %s", err.Error())
+					} else {
+						x.Log.Printf("Update completed successfully")
+					}
+				}
+				time.Sleep(*x.Config.Conf.Updates.CheckInterval)
+			}
+		}()
+	}
+
+	<-ctxMain.Done()
+	NodeApp.CallFallback(ctx)
+	return nil
+}
--- a/internal/engine/logs/color.go
+++ b/internal/engine/logs/color.go
@@ -1,4 +1,4 @@
-package logs
+package colors

 import "fmt"

--- a/internal/core/update/update.go
+++ b/internal/core/update/update.go
@@ -134,7 +134,7 @@ func (u *Updater) GetCurrentVersion() (Version, Branch, error) {
 }

 func (u *Updater) GetLatestVersion(updateBranch Branch) (Version, Branch, error) {
-	repoURL := u.x.Config.Conf.Updates.RepositoryURL
+	repoURL := *u.x.Config.Conf.Updates.RepositoryURL
 	if repoURL == "" {
 		u.x.Log.Printf("Failed to get latest version: %s", "RepositoryURL is empty in config")
 		return "", "", errors.New("repository URL is empty")
@@ -192,7 +192,7 @@ func (u *Updater) CkeckUpdates() (IsNewUpdate, error) {
 }

 func (u *Updater) Update() error {
-	if !u.x.Config.Conf.Updates.UpdatesEnabled {
+	if !*u.x.Config.Conf.Updates.UpdatesEnabled {
 		return errors.New("updates are disabled in config, skipping update")
 	}

@@ -212,7 +212,7 @@ func (u *Updater) Update() error {
 	}

 	updateArchiveName := fmt.Sprintf("%s.v%s-%s", config.UpdateArchiveName, latestVersion, latestBranch)
-	updateDest := fmt.Sprintf("%s/%s.%s", u.x.Config.Conf.Updates.RepositoryURL, updateArchiveName, "tar.gz")
+	updateDest := fmt.Sprintf("%s/%s.%s", *u.x.Config.Conf.Updates.RepositoryURL, updateArchiveName, "tar.gz")

 	resp, err := http.Get(updateDest)
 	if err != nil {
@@ -278,7 +278,7 @@ func (u *Updater) Update() error {

 func (u *Updater) InstallAndRestart() error {

-	nodePath := u.x.Config.Env.NodePath
+	nodePath := *u.x.Config.Env.NodePath
 	if nodePath == "" {
 		return errors.New("GS_NODE_PATH environment variable is not set")
 	}
--- a/internal/core/utils/panic.go
+++ b/internal/core/utils/panic.go
@@ -3,38 +3,14 @@ package utils
 import (
 	"log"
 	"runtime"
-	"strings"

 	"golang.org/x/net/context"
 )

-// temportary solution, pls dont judge
-func trimStackPaths(stack []byte, folderName string) []byte {
-	lines := strings.Split(string(stack), "\n")
-	for i, line := range lines {
-		idx := strings.Index(line, folderName)
-		if idx != -1 {
-			indentEnd := strings.LastIndex(line[:idx], "\t")
-			if indentEnd == -1 {
-				indentEnd = 0
-			} else {
-				indentEnd++
-			}
-			start := idx + len(folderName) + 1
-			if start > len(line) {
-				start = len(line)
-			}
-			lines[i] = line[:indentEnd] + line[start:]
-		}
-	}
-	return []byte(strings.Join(lines, "\n"))
-}
-
 func CatchPanic() {
 	if err := recover(); err != nil {
 		stack := make([]byte, 8096)
 		stack = stack[:runtime.Stack(stack, false)]
-		stack = trimStackPaths(stack, "GoSally-mvp")
 		log.Printf("recovered panic:\n%s", stack)
 	}
 }
@@ -43,7 +19,6 @@ func CatchPanicWithCancel(cancel context.CancelFunc) {
 	if err := recover(); err != nil {
 		stack := make([]byte, 8096)
 		stack = stack[:runtime.Stack(stack, false)]
-		stack = trimStackPaths(stack, "GoSally-mvp")
 		log.Printf("recovered panic:\n%s", stack)
 		cancel()
 	}
@@ -53,7 +28,6 @@ func CatchPanicWithFallback(onPanic func(any)) {
 	if err := recover(); err != nil {
 		stack := make([]byte, 8096)
 		stack = stack[:runtime.Stack(stack, false)]
-		stack = trimStackPaths(stack, "GoSally-mvp")
 		log.Printf("recovered panic:\n%s", stack)
 		onPanic(err)
 	}
--- a/internal/engine/app/app.go
+++ b/internal/engine/app/app.go
@@ -14,7 +14,7 @@ import (
 )

 type AppContract interface {
-	InitialHooks(fn ...func(cs *corestate.CoreState, x *AppX))
+	InitialHooks(fn ...func(ctx context.Context, cs *corestate.CoreState, x *AppX))
 	Run(fn func(ctx context.Context, cs *corestate.CoreState, x *AppX) error)
 	Fallback(fn func(ctx context.Context, cs *corestate.CoreState, x *AppX))

@@ -22,7 +22,7 @@ type AppContract interface {
 }

 type App struct {
-	initHooks []func(cs *corestate.CoreState, x *AppX)
+	initHooks []func(ctx context.Context, cs *corestate.CoreState, x *AppX)
 	runHook   func(ctx context.Context, cs *corestate.CoreState, x *AppX) error
 	fallback  func(ctx context.Context, cs *corestate.CoreState, x *AppX)

@@ -47,7 +47,7 @@ func New() AppContract {
 	}
 }

-func (a *App) InitialHooks(fn ...func(cs *corestate.CoreState, x *AppX)) {
+func (a *App) InitialHooks(fn ...func(ctx context.Context, cs *corestate.CoreState, x *AppX)) {
 	a.initHooks = append(a.initHooks, fn...)
 }

@@ -58,13 +58,13 @@ func (a *App) Fallback(fn func(ctx context.Context, cs *corestate.CoreState, x *
 func (a *App) Run(fn func(ctx context.Context, cs *corestate.CoreState, x *AppX) error) {
 	a.runHook = fn

-	for _, hook := range a.initHooks {
-		hook(a.Corestate, a.AppX)
-	}
-
 	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
 	defer stop()

+	for _, hook := range a.initHooks {
+		hook(ctx, a.Corestate, a.AppX)
+	}
+
 	defer func() {
 		if r := recover(); r != nil {
 			a.AppX.Log.Printf("PANIC recovered: %v", r)
@@ -90,5 +90,6 @@ func (a *App) CallFallback(ctx context.Context) {
 		if a.fallback != nil {
 			a.fallback(ctx, a.Corestate, a.AppX)
 		}
+		os.Exit(0)
 	})
 }
--- a/internal/engine/config/compositor.go
+++ b/internal/engine/config/compositor.go
@@ -43,10 +43,13 @@ func (c *Compositor) LoadConf(path string) error {
 	v.SetConfigType("yaml")

 	// defaults
-	v.SetDefault("mode", "dev")
-	v.SetDefault("com_dir", "./com/")
+	v.SetDefault("node.name", "noname")
+	v.SetDefault("node.mode", "dev")
+	v.SetDefault("node.show_config", "false")
+	v.SetDefault("node.com_dir", "./com/")
 	v.SetDefault("http_server.address", "0.0.0.0")
 	v.SetDefault("http_server.port", "8080")
+	v.SetDefault("http_server.session_ttl", "30m")
 	v.SetDefault("http_server.timeout", "5s")
 	v.SetDefault("http_server.idle_timeout", "60s")
 	v.SetDefault("tls.enabled", false)
@@ -55,8 +58,9 @@ func (c *Compositor) LoadConf(path string) error {
 	v.SetDefault("updates.enabled", false)
 	v.SetDefault("updates.check_interval", "2h")
 	v.SetDefault("updates.wanted_version", "latest-stable")
+	v.SetDefault("log.json_format", "false")
 	v.SetDefault("log.level", "info")
-	v.SetDefault("log.out_path", "")
+	v.SetDefault("log.output", "%2%")

 	if err := v.ReadInConfig(); err != nil {
 		return fmt.Errorf("error reading config: %w", err)
--- a/internal/engine/config/config.go
+++ b/internal/engine/config/config.go
@@ -18,51 +18,53 @@ type Compositor struct {
 }

 type Conf struct {
-	Mode            string     `mapstructure:"mode"`
-	ComDir          string     `mapstructure:"com_dir"`
-	HTTPServer      HTTPServer `mapstructure:"http_server"`
-	TLS             TLS        `mapstructure:"tls"`
-	Updates         Updates    `mapstructure:"updates"`
-	Log             Log        `mapstructure:"log"`
-	DisableWarnings []string   `mapstructure:"disable_warnings"`
+	Node            *Node       `mapstructure:"node"`
+	HTTPServer      *HTTPServer `mapstructure:"http_server"`
+	TLS             *TLS        `mapstructure:"tls"`
+	Updates         *Updates    `mapstructure:"updates"`
+	Log             *Log        `mapstructure:"log"`
+	DisableWarnings *[]string   `mapstructure:"disable_warnings"`
+}
+
+type Node struct {
+	Mode       *string `mapstructure:"mode"`
+	Name       *string `mapstructure:"name"`
+	ShowConfig *bool   `mapstructure:"show_config"`
+	ComDir     *string `mapstructure:"com_dir"`
 }

 type HTTPServer struct {
-	Address        string         `mapstructure:"address"`
-	Port           string         `mapstructure:"port"`
-	Timeout        time.Duration  `mapstructure:"timeout"`
-	IdleTimeout    time.Duration  `mapstructure:"idle_timeout"`
-	HTTPServer_Api HTTPServer_Api `mapstructure:"api"`
-}
-
-type HTTPServer_Api struct {
-	LatestVer string   `mapstructure:"latest-version"`
-	Layers    []string `mapstructure:"layers"`
+	Address     *string        `mapstructure:"address"`
+	Port        *string        `mapstructure:"port"`
+	SessionTTL  *time.Duration `mapstructure:"session_ttl"`
+	Timeout     *time.Duration `mapstructure:"timeout"`
+	IdleTimeout *time.Duration `mapstructure:"idle_timeout"`
 }

 type TLS struct {
-	TlsEnabled bool   `mapstructure:"enabled"`
-	CertFile   string `mapstructure:"cert_file"`
-	KeyFile    string `mapstructure:"key_file"`
+	TlsEnabled *bool   `mapstructure:"enabled"`
+	CertFile   *string `mapstructure:"cert_file"`
+	KeyFile    *string `mapstructure:"key_file"`
 }

 type Updates struct {
-	UpdatesEnabled bool          `mapstructure:"enabled"`
-	CheckInterval  time.Duration `mapstructure:"check_interval"`
-	RepositoryURL  string        `mapstructure:"repository_url"`
-	WantedVersion  string        `mapstructure:"wanted_version"`
+	UpdatesEnabled *bool          `mapstructure:"enabled"`
+	CheckInterval  *time.Duration `mapstructure:"check_interval"`
+	RepositoryURL  *string        `mapstructure:"repository_url"`
+	WantedVersion  *string        `mapstructure:"wanted_version"`
 }

 type Log struct {
-	Level   string `mapstructure:"level"`
-	OutPath string `mapstructure:"out_path"`
+	JSON    *bool   `mapstructure:"json_format"`
+	Level   *string `mapstructure:"level"`
+	OutPath *string `mapstructure:"output"`
 }

 // ConfigEnv structure for environment variables
 type Env struct {
-	ConfigPath     string `mapstructure:"config_path"`
-	NodePath       string `mapstructure:"node_path"`
-	ParentStagePID int    `mapstructure:"parent_pid"`
+	ConfigPath     *string `mapstructure:"config_path"`
+	NodePath       *string `mapstructure:"node_path"`
+	ParentStagePID *int    `mapstructure:"parent_pid"`
 }

 type CMDLine struct {
--- a/internal/engine/config/consts.go
+++ b/internal/engine/config/consts.go
@@ -2,6 +2,8 @@ package config

 import "os"

+// TODO: Need to make a more harmonious and understandable way of storing global variables
+
 // UUIDLength is uuids length for sessions. By default it is 16 bytes.
 var UUIDLength int = 16

--- a/internal/engine/config/print.go
+++ b/internal/engine/config/print.go
@@ -0,0 +1,72 @@
+package config
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+
+	"github.com/akyaiy/GoSally-mvp/internal/colors"
+)
+
+func (c *Compositor) Print(v any) {
+	c.printConfig(v, "  ")
+}
+
+func (c *Compositor) printConfig(v any, prefix string) {
+	val := reflect.ValueOf(v)
+	if val.Kind() == reflect.Ptr {
+		val = val.Elem()
+	}
+
+	typ := val.Type()
+
+	for i := 0; i < val.NumField(); i++ {
+		field := val.Field(i)
+		fieldType := typ.Field(i)
+
+		fieldName := fieldType.Name
+		if tag, ok := fieldType.Tag.Lookup("mapstructure"); ok {
+			if tag != "" {
+				fieldName = tag
+			}
+		}
+
+		coloredFieldName := colors.SetBrightCyan(fieldName)
+
+		if field.Kind() == reflect.Ptr {
+			if field.IsNil() {
+				fmt.Printf("%s%s: %s\n", prefix, coloredFieldName, colors.SetBrightRed("<nil>"))
+				continue
+			}
+			field = field.Elem()
+		}
+
+		if field.Kind() == reflect.Struct {
+			if field.Type() == reflect.TypeOf(time.Duration(0)) {
+				duration := field.Interface().(time.Duration)
+				fmt.Printf("%s%s: %s\n",
+					prefix,
+					coloredFieldName,
+					colors.SetBrightYellow(duration.String()))
+			} else {
+				fmt.Printf("%s%s:\n", prefix, coloredFieldName)
+				c.printConfig(field.Addr().Interface(), prefix+"  ")
+			}
+		} else if field.Kind() == reflect.Slice {
+			fmt.Printf("%s%s: %s\n",
+				prefix,
+				coloredFieldName,
+				colors.SetBrightYellow(fmt.Sprintf("%v", field.Interface())))
+		} else {
+			value := field.Interface()
+			valueStr := fmt.Sprintf("%v", value)
+			if field.Kind() == reflect.String {
+				valueStr = fmt.Sprintf("\"%s\"", value)
+			}
+			fmt.Printf("%s%s: %s\n",
+				prefix,
+				coloredFieldName,
+				colors.SetBrightYellow(valueStr))
+		}
+	}
+}
--- a/internal/engine/logs/logger.go
+++ b/internal/engine/logs/logger.go
@@ -10,16 +10,25 @@ import (
 	"log/slog"
 	"os"
 	"path/filepath"
-	"regexp"
-	"strings"

-	"github.com/akyaiy/GoSally-mvp/internal/core/run_manager"
 	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
 	"gopkg.in/natefinch/lumberjack.v2"
 )

 var GlobalLevel slog.Level

+type levelsStruct struct {
+	Available []string
+	Fallback  string
+}
+
+var Levels = levelsStruct{
+	Available: []string{
+		"debug", "info",
+	},
+	Fallback: "info",
+}
+
 type SlogWriter struct {
 	Logger *slog.Logger
 	Level  slog.Level
@@ -32,11 +41,11 @@ func (w *SlogWriter) Write(p []byte) (n int, err error) {
 }

 // SetupLogger initializes and returns a logger based on the provided environment.
-func SetupLogger(o config.Log) (*slog.Logger, error) {
+func SetupLogger(o *config.Log) (*slog.Logger, error) {
 	var handlerOpts = slog.HandlerOptions{}
 	var writer io.Writer = os.Stdout

-	switch o.Level {
+	switch *o.Level {
 	case "debug":
 		GlobalLevel = slog.LevelDebug
 		handlerOpts.Level = slog.LevelDebug
@@ -48,32 +57,14 @@ func SetupLogger(o config.Log) (*slog.Logger, error) {
 		handlerOpts.Level = slog.LevelInfo
 	}

-	if o.OutPath != "" {
-		repl := map[string]string{
-			"tmp": filepath.Clean(run_manager.RuntimeDir()),
-		}
-		re := regexp.MustCompile(`%(\w+)%`)
-		result := re.ReplaceAllStringFunc(o.OutPath, func(match string) string {
-			sub := re.FindStringSubmatch(match)
-			if len(sub) < 2 {
-				return match
-			}
-			key := sub[1]
-			if val, ok := repl[key]; ok {
-				return val
-			}
-			return match
-		})
-
-		if strings.Contains(o.OutPath, "%tmp%") {
-			relPath := strings.TrimPrefix(result, filepath.Clean(run_manager.RuntimeDir()))
-			if err := run_manager.SetDir(relPath); err != nil {
-				return nil, err
-			}
-		}
-
+	switch *o.OutPath {
+	case "_1STDout":
+		writer = os.Stdout
+	case "_2STDerr":
+		writer = os.Stderr
+	default:
 		logFile := &lumberjack.Logger{
-			Filename:   filepath.Join(result, "event.log"),
+			Filename:   filepath.Join(*o.OutPath, "event.log"),
 			MaxSize:    10,
 			MaxBackups: 5,
 			MaxAge:     28,
@@ -82,6 +73,13 @@ func SetupLogger(o config.Log) (*slog.Logger, error) {
 		writer = logFile
 	}

-	log := slog.New(slog.NewJSONHandler(writer, &handlerOpts))
+	var handler slog.Handler
+
+	if *o.JSON {
+		handler = slog.NewJSONHandler(writer, &handlerOpts)
+	} else {
+		handler = slog.NewTextHandler(writer, &handlerOpts)
+	}
+	log := slog.New(handler)
 	return log, nil
 }
--- a/internal/server/gateway/general_types.go
+++ b/internal/server/gateway/general_types.go
@@ -1,11 +1,13 @@
 package gateway

 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"
 )

 // serversApiVer is a type alias for string, used to represent API version strings in the GeneralServer.
@@ -13,7 +15,7 @@ type serversApiVer string

 type ServerApiContract interface {
 	GetVersion() string
-	Handle(r *http.Request, req *rpc.RPCRequest) *rpc.RPCResponse
+	Handle(ctx context.Context, sid string, r *http.Request, req *rpc.RPCRequest) *rpc.RPCResponse
 }

 // GeneralServer implements the GeneralServerApiContract and serves as a router for different API versions.
@@ -22,6 +24,7 @@ type GatewayServer struct {
 	// The key is the version string, and the value is the server implementing GeneralServerApi
 	servers map[serversApiVer]ServerApiContract

+	sm *session.SessionManager
 	cs *corestate.CoreState
 	x  *app.AppX
 }
--- a/internal/server/gateway/init.go
+++ b/internal/server/gateway/init.go
@@ -5,10 +5,12 @@ import (

 	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
 	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/internal/server/session"
 )

 // GeneralServerInit structure only for initialization general server.
 type GatewayServerInit struct {
+	SM *session.SessionManager
 	CS *corestate.CoreState
 	X  *app.AppX
 }
@@ -17,6 +19,7 @@ type GatewayServerInit struct {
 func InitGateway(o *GatewayServerInit, servers ...ServerApiContract) *GatewayServer {
 	general := &GatewayServer{
 		servers: make(map[serversApiVer]ServerApiContract),
+		sm:      o.SM,
 		cs:      o.CS,
 		x:       o.X,
 	}
--- a/internal/server/gateway/route.go
+++ b/internal/server/gateway/route.go
@@ -1,6 +1,7 @@
 package gateway

 import (
+	"context"
 	"encoding/json"
 	"io"
 	"log/slog"
@@ -9,12 +10,35 @@ import (

 	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
 	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+	"github.com/google/uuid"
 )

 func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context() // TODO
+
 	w.Header().Set("Content-Type", "application/json")
+	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,
+			},
+		})
+		return
+	}
+	defer gs.sm.Delete(sessionUUID)
+
 	body, err := io.ReadAll(r.Body)
 	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,
@@ -34,6 +58,7 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 	var single rpc.RPCRequest
 	if batch == nil {
 		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,
@@ -46,7 +71,11 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 			gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrParseErrorS))
 			return
 		}
-		resp := gs.Route(r, &single)
+		resp := gs.Route(ctx, sessionUUID, r, &single)
+		if resp == nil {
+			w.Write([]byte(""))
+			return
+		}
 		rpc.WriteResponse(w, resp)
 		return
 	}
@@ -58,7 +87,7 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 		wg.Add(1)
 		go func(req rpc.RPCRequest) {
 			defer wg.Done()
-			res := gs.Route(r, &req)
+			res := gs.Route(ctx, sessionUUID, r, &req)
 			if res != nil {
 				responses <- *res
 			}
@@ -73,29 +102,31 @@ func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
 	}
 	if len(result) > 0 {
 		json.NewEncoder(w).Encode(result)
+	} else {
+		w.Write([]byte("[]"))
 	}
 }

-func (gs *GatewayServer) Route(r *http.Request, req *rpc.RPCRequest) (resp *rpc.RPCResponse) {
+func (gs *GatewayServer) Route(ctx context.Context, sid string, r *http.Request, req *rpc.RPCRequest) (resp *rpc.RPCResponse) {
 	defer utils.CatchPanicWithFallback(func(rec any) {
 		gs.x.SLog.Error("panic caught in handler", slog.Any("error", rec))
-		resp = rpc.NewError(rpc.ErrInternalError, "Internal server error (panic)", req.ID)
+		resp = rpc.NewError(rpc.ErrInternalError, "Internal server error (panic)", nil, req.ID)
 	})
 	if req.JSONRPC != rpc.JSONRPCVersion {
 		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInvalidRequestS), slog.String("requested-version", req.JSONRPC))
-		return rpc.NewError(rpc.ErrInvalidRequest, rpc.ErrInvalidRequestS, req.ID)
+		return rpc.NewError(rpc.ErrInvalidRequest, rpc.ErrInvalidRequestS, nil, req.ID)
 	}

 	server, ok := gs.servers[serversApiVer(req.ContextVersion)]
 	if !ok {
 		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrContextVersionS), slog.String("requested-version", req.ContextVersion))
-		return rpc.NewError(rpc.ErrContextVersion, rpc.ErrContextVersionS, req.ID)
+		return rpc.NewError(rpc.ErrContextVersion, rpc.ErrContextVersionS, nil, req.ID)
 	}

-	resp = server.Handle(r, req)
 	// checks if request is notification
 	if req.ID == nil {
+		go server.Handle(ctx, sid, r, req)
 		return nil
 	}
-	return resp
+	return server.Handle(ctx, sid, r, req)
 }
--- a/internal/server/rpc/errors.go
+++ b/internal/server/rpc/errors.go
@@ -24,4 +24,7 @@ const (

 	ErrMethodIsMissing  = -32020
 	ErrMethodIsMissingS = "Method is missing"
+
+	ErrSessionIsBusy  = -32030
+	ErrSessionIsBusyS = "The session is busy"
 )
--- a/internal/server/rpc/responsers.go
+++ b/internal/server/rpc/responsers.go
@@ -2,7 +2,18 @@ package rpc

 import "encoding/json"

-func NewError(code int, message string, id *json.RawMessage) *RPCResponse {
+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,
--- a/internal/server/session/manager.go
+++ b/internal/server/session/manager.go
@@ -0,0 +1,47 @@
+package session
+
+import (
+	"sync"
+	"time"
+)
+
+type SessionManagerContract interface {
+	Add(uuid string) bool
+	Delete(uuid string)
+	StartCleanup(interval time.Duration)
+}
+
+type SessionManager struct {
+	sessions sync.Map
+	ttl      time.Duration
+}
+
+func New(ttl time.Duration) *SessionManager {
+	return &SessionManager{
+		ttl: ttl,
+	}
+}
+
+func (sm *SessionManager) Add(uuid string) bool {
+	_, loaded := sm.sessions.LoadOrStore(uuid, time.Now().Add(sm.ttl))
+	return !loaded
+}
+
+func (sm *SessionManager) Delete(uuid string) {
+	sm.sessions.Delete(uuid)
+}
+
+func (sm *SessionManager) StartCleanup(interval time.Duration) {
+	go func() {
+		ticker := time.NewTicker(interval)
+		for range ticker.C {
+			sm.sessions.Range(func(key, value any) bool {
+				expiry := value.(time.Time)
+				if time.Now().After(expiry) {
+					sm.sessions.Delete(key)
+				}
+				return true
+			})
+		}
+	}()
+}
--- a/internal/server/sv1/handle.go
+++ b/internal/server/sv1/handle.go
@@ -1,151 +1,29 @@
 package sv1

 import (
-	"fmt"
+	"context"
 	"log/slog"
 	"net/http"
-	"os"
-	"path/filepath"
-	"strconv"

-	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
-	"github.com/akyaiy/GoSally-mvp/internal/engine/logs"
 	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
-	lua "github.com/yuin/gopher-lua"
 )

-func (h *HandlerV1) Handle(r *http.Request, req *rpc.RPCRequest) *rpc.RPCResponse {
+func (h *HandlerV1) Handle(_ context.Context, sid string, r *http.Request, req *rpc.RPCRequest) *rpc.RPCResponse {
 	if req.Method == "" {
 		h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrMethodNotFoundS), slog.String("requested-method", req.Method))
-		return rpc.NewError(rpc.ErrMethodIsMissing, rpc.ErrMethodIsMissingS, req.ID)
+		return rpc.NewError(rpc.ErrMethodIsMissing, rpc.ErrMethodIsMissingS, nil, req.ID)
 	}

 	method, err := h.resolveMethodPath(req.Method)
 	if err != nil {
 		if err.Error() == rpc.ErrInvalidMethodFormatS {
 			h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInvalidMethodFormatS), slog.String("requested-method", req.Method))
-			return rpc.NewError(rpc.ErrInvalidMethodFormat, rpc.ErrInvalidMethodFormatS, req.ID)
+			return rpc.NewError(rpc.ErrInvalidMethodFormat, rpc.ErrInvalidMethodFormatS, nil, req.ID)
 		} else if err.Error() == rpc.ErrMethodNotFoundS {
 			h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrMethodNotFoundS), slog.String("requested-method", req.Method))
-			return rpc.NewError(rpc.ErrMethodNotFound, rpc.ErrMethodNotFoundS, req.ID)
+			return rpc.NewError(rpc.ErrMethodNotFound, rpc.ErrMethodNotFoundS, nil, req.ID)
 		}
 	}

-	return h.HandleLUA(method, req)
-}
-
-func (h *HandlerV1) HandleLUA(path string, req *rpc.RPCRequest) *rpc.RPCResponse {
-	L := lua.NewState()
-	defer L.Close()
-
-	inTable := L.NewTable()
-	paramsTable := L.NewTable()
-	if fetchedParams, ok := req.Params.(map[string]any); ok {
-		for k, v := range fetchedParams {
-			L.SetField(paramsTable, k, utils.ConvertGolangTypesToLua(L, v))
-		}
-	}
-	L.SetField(inTable, "Params", paramsTable)
-	L.SetGlobal("In", inTable)
-
-	outTable := L.NewTable()
-	resultTable := L.NewTable()
-	L.SetField(outTable, "Result", resultTable)
-	L.SetGlobal("Out", outTable)
-
-	logTable := L.NewTable()
-
-	L.SetField(logTable, "Info", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.SLog.Info(fmt.Sprintf("the script says: %s", msg), slog.String("script", path))
-		return 0
-	}))
-
-	L.SetField(logTable, "Debug", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.SLog.Debug(fmt.Sprintf("the script says: %s", msg), slog.String("script", path))
-		return 0
-	}))
-
-	L.SetField(logTable, "Error", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.SLog.Error(fmt.Sprintf("the script says: %s", msg), slog.String("script", path))
-		return 0
-	}))
-
-	L.SetField(logTable, "Warn", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.SLog.Warn(fmt.Sprintf("the script says: %s", msg), slog.String("script", path))
-		return 0
-	}))
-
-	L.SetField(logTable, "Event", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.Log.Printf("%s: %s", path, msg)
-		return 0
-	}))
-
-	L.SetField(logTable, "EventError", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.Log.Printf("%s: %s: %s", logs.PrintError(), path, msg)
-		return 0
-	}))
-
-	L.SetField(logTable, "EventWarn", L.NewFunction(func(L *lua.LState) int {
-		msg := L.ToString(1)
-		h.x.Log.Printf("%s: %s: %s", logs.PrintWarn(), path, msg)
-		return 0
-	}))
-
-	registerDatabaseType(L)
-
-	L.SetGlobal("Log", logTable)
-
-	prep := filepath.Join(h.x.Config.Conf.ComDir, "_prepare.lua")
-	if _, err := os.Stat(prep); err == nil {
-		if err := L.DoFile(prep); err != nil {
-			return rpc.NewError(rpc.ErrInternalError, err.Error(), req.ID)
-		}
-	}
-	if err := L.DoFile(path); err != nil {
-		return rpc.NewError(rpc.ErrInternalError, err.Error(), req.ID)
-	}
-
-	lv := L.GetGlobal("Out")
-	outTbl, ok := lv.(*lua.LTable)
-	if !ok {
-		return rpc.NewError(rpc.ErrInternalError, "Out is not a table", req.ID)
-	}
-
-	// Check if Out.Error exists
-	if errVal := outTbl.RawGetString("Error"); errVal != lua.LNil {
-		if errTbl, ok := errVal.(*lua.LTable); ok {
-			code := rpc.ErrInternalError
-			message := "Internal script error"
-			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()
-			}
-			h.x.SLog.Error("the script terminated with an error", slog.String("code", strconv.Itoa(code)), slog.String("message", message))
-			return rpc.NewError(code, message, req.ID)
-		}
-		return rpc.NewError(rpc.ErrInternalError, "Out.Error is not a table", req.ID)
-	}
-
-	// Otherwise, parse Out.Result
-	resultVal := outTbl.RawGetString("Result")
-	resultTbl, ok := resultVal.(*lua.LTable)
-	if !ok {
-		return rpc.NewError(rpc.ErrInternalError, "Out.Result is not a table", req.ID)
-	}
-
-	out := make(map[string]any)
-	resultTbl.ForEach(func(key lua.LValue, value lua.LValue) {
-		out[key.String()] = utils.ConvertLuaTypesToGolang(value)
-	})
-
-	out["responsible-node"] = h.cs.UUID32
-	return rpc.NewResponse(out, req.ID)
+	return h.handleLUA(sid, r, req, method)
 }
--- a/internal/server/sv1/lua_handler.go
+++ b/internal/server/sv1/lua_handler.go
@@ -0,0 +1,653 @@
+package sv1
+
+// TODO: make a lua state pool using sync.Pool
+
+import (
+	"database/sql"
+	"fmt"
+	"io"
+	"log/slog"
+	"math/rand/v2"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/akyaiy/GoSally-mvp/internal/colors"
+	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+	lua "github.com/yuin/gopher-lua"
+	_ "modernc.org/sqlite"
+)
+
+type DBConnection struct {
+	dbPath    string
+	log       bool
+	logger    *slog.Logger
+	writeChan chan *dbWriteRequest
+	closeChan chan struct{}
+}
+
+type dbWriteRequest struct {
+	query string
+	args  []interface{}
+	resCh chan *dbWriteResult
+}
+
+type dbWriteResult struct {
+	rowsAffected int64
+	err          error
+}
+
+var dbMutexMap = make(map[string]*sync.RWMutex)
+var dbGlobalMutex sync.Mutex
+
+func getDBMutex(dbPath string) *sync.RWMutex {
+	dbGlobalMutex.Lock()
+	defer dbGlobalMutex.Unlock()
+
+	if mtx, ok := dbMutexMap[dbPath]; ok {
+		return mtx
+	}
+
+	mtx := &sync.RWMutex{}
+	dbMutexMap[dbPath] = mtx
+	return mtx
+}
+
+func loadDBMod(llog *slog.Logger) func(*lua.LState) int {
+	llog.Debug("import module db-sqlite")
+	return func(L *lua.LState) int {
+		dbMod := L.NewTable()
+
+		L.SetField(dbMod, "connect", L.NewFunction(func(L *lua.LState) int {
+			dbPath := L.CheckString(1)
+
+			logQueries := false
+			if L.GetTop() >= 2 {
+				opts := L.CheckTable(2)
+				if val := opts.RawGetString("log"); val != lua.LNil {
+					logQueries = lua.LVAsBool(val)
+				}
+			}
+
+			conn := &DBConnection{
+				dbPath:    dbPath,
+				log:       logQueries,
+				logger:    llog,
+				writeChan: make(chan *dbWriteRequest, 100),
+				closeChan: make(chan struct{}),
+			}
+
+			go conn.processWrites()
+
+			ud := L.NewUserData()
+			ud.Value = conn
+			L.SetMetatable(ud, L.GetTypeMetatable("gosally_db"))
+
+			L.Push(ud)
+			return 1
+		}))
+
+		mt := L.NewTypeMetatable("gosally_db")
+		L.SetField(mt, "__index", L.SetFuncs(L.NewTable(), map[string]lua.LGFunction{
+			"exec":  dbExec,
+			"query": dbQuery,
+			"close": dbClose,
+		}))
+
+		L.SetField(dbMod, "__gosally_internal", lua.LString("0"))
+		L.Push(dbMod)
+		return 1
+	}
+}
+
+func (conn *DBConnection) processWrites() {
+	for {
+		select {
+		case req := <-conn.writeChan:
+			mtx := getDBMutex(conn.dbPath)
+			mtx.Lock()
+
+			db, err := sql.Open("sqlite", conn.dbPath+"?_busy_timeout=5000&_journal_mode=WAL&_sync=NORMAL&_cache_size=-10000")
+			if err == nil {
+				_, err = db.Exec("PRAGMA journal_mode=WAL;")
+				if err == nil {
+					res, execErr := db.Exec(req.query, req.args...)
+					if execErr == nil {
+						rows, _ := res.RowsAffected()
+						req.resCh <- &dbWriteResult{rowsAffected: rows}
+					} else {
+						req.resCh <- &dbWriteResult{err: execErr}
+					}
+				}
+				db.Close()
+			}
+
+			if err != nil {
+				req.resCh <- &dbWriteResult{err: err}
+			}
+
+			mtx.Unlock()
+		case <-conn.closeChan:
+			return
+		}
+	}
+}
+
+func dbExec(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 Exec",
+			slog.String("query", query),
+			slog.Any("params", args))
+	}
+
+	resCh := make(chan *dbWriteResult, 1)
+	conn.writeChan <- &dbWriteRequest{
+		query: query,
+		args:  args,
+		resCh: resCh,
+	}
+
+	ctx := L.NewTable()
+	L.SetField(ctx, "done", lua.LBool(false))
+	
+	var result lua.LValue = lua.LNil
+	var errorMsg lua.LValue = lua.LNil
+
+	L.SetField(ctx, "wait", L.NewFunction(func(lL *lua.LState) int {
+		res := <-resCh
+		L.SetField(ctx, "done", lua.LBool(true))
+		
+		if res.err != nil {
+			errorMsg = lua.LString(res.err.Error())
+			result = lua.LNil
+		} else {
+			result = lua.LNumber(res.rowsAffected)
+			errorMsg = lua.LNil
+		}
+		
+		if res.err != nil {
+			lL.Push(lua.LNil)
+			lL.Push(lua.LString(res.err.Error()))
+			return 2
+		}
+		lL.Push(lua.LNumber(res.rowsAffected))
+		lL.Push(lua.LNil)
+		return 2
+	}))
+
+	L.SetField(ctx, "check", L.NewFunction(func(lL *lua.LState) int {
+		select {
+		case res := <-resCh:
+			lL.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()))
+				return 2
+			} else {
+				result = lua.LNumber(res.rowsAffected)
+				errorMsg = lua.LNil
+				lL.Push(lua.LNumber(res.rowsAffected))
+				lL.Push(lua.LNil)
+				return 2
+			}
+		default:
+			lL.Push(result)
+			lL.Push(errorMsg)
+			return 2
+		}
+	}))
+
+	L.Push(ctx)
+	L.Push(lua.LNil)
+	return 2
+}
+
+func dbQuery(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 Query",
+			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()
+
+	rows, err := db.Query(query, args...)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("query failed: %v", err)))
+		return 2
+	}
+	defer rows.Close()
+
+	columns, err := rows.Columns()
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("get columns failed: %v", err)))
+		return 2
+	}
+
+	result := L.NewTable()
+	colCount := len(columns)
+	values := make([]any, colCount)
+	valuePtrs := make([]any, colCount)
+
+	for rows.Next() {
+		for i := range columns {
+			valuePtrs[i] = &values[i]
+		}
+
+		if err := rows.Scan(valuePtrs...); err != nil {
+			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))
+			}
+		}
+		result.Append(rowTable)
+	}
+
+	if err := rows.Err(); err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("rows iteration failed: %v", err)))
+		return 2
+	}
+
+	L.Push(result)
+	return 1
+}
+
+func dbClose(L *lua.LState) int {
+	ud := L.CheckUserData(1)
+	conn, ok := ud.Value.(*DBConnection)
+	if !ok {
+		L.Push(lua.LFalse)
+		L.Push(lua.LString("invalid database connection"))
+		return 2
+	}
+
+	close(conn.closeChan)
+	L.Push(lua.LTrue)
+	return 1
+}
+
+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
+	}
+
+	L.PreloadModule("internal.session", loadSessionMod)
+	L.PreloadModule("internal.log", loadLogMod)
+	L.PreloadModule("internal.net", loadNetMod)
+	L.PreloadModule("internal.database-sqlite", loadDBMod(llog))
+
+	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)
+}
--- a/internal/core/utils/internal_lua.go
+++ b/internal/core/utils/internal_lua.go
@@ -1,4 +1,4 @@
-package utils
+package sv1

 import (
 	"fmt"
@@ -17,7 +17,6 @@ func ConvertLuaTypesToGolang(value lua.LValue) any {
 	case lua.LTTable:
 		tbl := value.(*lua.LTable)

-		// Попробуем как массив
 		var arr []any
 		isArray := true
 		tbl.ForEach(func(key, val lua.LValue) {
--- a/internal/server/sv1/path.go
+++ b/internal/server/sv1/path.go
@@ -16,7 +16,7 @@ func (h *HandlerV1) resolveMethodPath(method string) (string, error) {

 	parts := strings.Split(method, ">")
 	relPath := filepath.Join(parts...) + ".lua"
-	fullPath := filepath.Join(h.x.Config.Conf.ComDir, relPath)
+	fullPath := filepath.Join(*h.x.Config.Conf.Node.ComDir, relPath)

 	if _, err := os.Stat(fullPath); os.IsNotExist(err) {
 		return "", errors.New(rpc.ErrMethodNotFoundS)
--- a/main.go
+++ b/main.go
@@ -2,6 +2,7 @@ package main

 import (
 	"github.com/akyaiy/GoSally-mvp/cmd"
+	_ "modernc.org/sqlite"
 )

 func main() {
Author	SHA1	Message	Date
Aleksey	a6c9e5102f	Merge branch 'main' into dev	2025-08-04 15:13:55 +03:00
Alexey	a72627d87c	delete table creation	2025-08-04 13:38:27 +03:00
Alexey	4a9719cdfb	sqlite usage example	2025-08-04 13:36:38 +03:00
Alexey	7de5ec5248	add sqlite support	2025-08-04 13:36:30 +03:00
Alexey	e5f9105364	change cors	2025-08-04 13:36:21 +03:00
Alexey	ce2a23f9e6	make internal modules in "internal"	2025-08-02 16:22:05 +03:00
Alexey	d56b022bf5	add com/test.lua to .gitignore	2025-08-02 16:13:22 +03:00
Alexey	ca38c10ec4	made creation of private field before pushing	2025-08-02 16:12:44 +03:00
Alexey	13dbd00bb7	update config exaple	2025-08-02 16:12:08 +03:00
Alexey	e7289dc9be	update post example	2025-08-02 11:50:19 +03:00
Alexey	5394178abc	update lua logging	2025-08-02 11:50:09 +03:00
Alexey	981551e944	change default log output to stderr	2025-08-02 10:14:35 +03:00
Alexey	27446adf3f	add debug information to lua_handler and route	2025-08-02 10:04:00 +03:00
Alexey	2f071c25b2	update annotations	2025-08-02 01:02:59 +03:00
Alexey	d23fd32e84	update annotations	2025-08-02 01:01:05 +03:00
Alexey	86d35a9ede	update annotations	2025-08-02 00:55:59 +03:00
Alexey	c77d51a95c	some changes with config.log.output	2025-08-02 00:53:19 +03:00
Alexey	3cbea14e84	fmt	2025-08-02 00:00:43 +03:00
Alexey	6e59af1662	add json_format option for structure logging	2025-08-02 00:00:35 +03:00
Alexey	8684d178e0	update Get example	2025-08-01 23:54:44 +03:00
Alexey	945ab6c9cf	update annotations	2025-08-01 23:53:40 +03:00
Alexey	520901c331	update script error handling	2025-08-01 23:53:30 +03:00
Alexey	9a274250cd	update annotations	2025-08-01 23:25:46 +03:00
Alexey	6d49d83ea7	update List.lua	2025-08-01 23:25:36 +03:00
Alexey	fb04b3bc46	change in/out to request/response	2025-08-01 23:25:24 +03:00
Alexey	a60b75a4c0	make lua deps modular	2025-08-01 23:18:45 +03:00
Alexey	041fda8522	change ErrSessionIsTaken to EssSessionIsBusy	2025-08-01 20:07:15 +03:00
Alexey	6508f03d08	fmt	2025-08-01 13:12:57 +03:00
Alexey	93cf53025c	rename init hooks names	2025-08-01 13:12:27 +03:00
Alexey	83912b6c28	add context TODO	2025-08-01 12:56:09 +03:00
Alexey	6ed5a7f9e0	add context to Handle method	2025-08-01 12:55:58 +03:00
Alexey	2f78e9367c	update logger initialization	2025-08-01 12:55:35 +03:00
Alexey	ac074ce0ff	change mapstructure to output	2025-08-01 12:55:17 +03:00
Alexey	8bdf9197d6	set default config value to stdout	2025-08-01 12:54:58 +03:00
Alexey	4db8fa2360	change fallback os exit to 0	2025-08-01 12:54:41 +03:00
Alexey	2a48927a08	update hooks	2025-08-01 12:54:28 +03:00
Alexey	58027bb988	add config processing	2025-08-01 12:54:18 +03:00
Alexey	30a87fdb4c	update List.lua	2025-08-01 12:53:25 +03:00
Alexey	5cdfb2a543	config confirmation	2025-08-01 00:56:05 +03:00
Alexey	08e96aa32a	add optional config preview with confirmation	2025-08-01 00:08:38 +03:00
Alexey	3b8390a0c8	basically added session manager, minimal. stores uuid and ttl sessions to eliminate recursive queries	2025-07-31 23:29:30 +03:00
Alexey	b6ad0f82a0	add Post example	2025-07-31 21:47:09 +03:00
Alexey	7009828e79	swap stages colors	2025-07-31 21:32:35 +03:00
Alexey	45e541ac00	update Config structure and add node name parameter	2025-07-31 21:30:59 +03:00
Alexey	a5a7354061	add a small reminder	2025-07-31 20:56:25 +03:00
Alexey	20bb90e77a	oh again update Get example	2025-07-31 20:51:30 +03:00
Alexey	148ca53538	update Net.Http.Get example	2025-07-31 20:46:02 +03:00
Alexey	2951fd2da9	add Net.Http.Get usage example	2025-07-31 20:39:44 +03:00
Alexey	f411637520	add Net.Http to lua	2025-07-31 20:37:31 +03:00
Alexey	75ee6e10aa	change http server log level to LevelError	2025-07-31 19:48:06 +03:00
Alexey	cfa7724b68	add exception for unknown logging level	2025-07-30 20:16:49 +03:00
Alexey	f44e89b0de	add new initialization hook to check configuration	2025-07-30 19:19:27 +03:00
Alexey	23ed707029	make fields in configuration structures pointers, fix errors in code related to this change	2025-07-30 19:19:02 +03:00
Alexey	299fd59e19	move %tmp% dereferencing to stage 6 of initialization, using a simpler and more efficient way of checking for contents	2025-07-30 19:17:36 +03:00
Alexey	b601962354	add TO DO to config/consts.go	2025-07-30 18:43:07 +03:00
Alexey	38f784b850	remove unused server api settings	2025-07-30 18:41:50 +03:00
Alexey	6d2bf5cdd2	add "about" to scripts you can get a description if you send a request where in params there is a field about with any content	2025-07-30 18:32:38 +03:00
Alexey	166c8470d4	add -ldflags "-w -s" and binary compression	2025-07-30 15:01:01 +03:00
Alexey	64510a5307	remove stackTrimPaths from CatchPanic, and add -trimpath to Makefile	2025-07-30 14:51:29 +03:00
Alexey	b454f4de8d	delete useless comment	2025-07-30 14:12:49 +03:00
Alexey	c161639766	move lua types converters from utils to sv1	2025-07-30 14:12:10 +03:00
Alexey	dd336a7d9a	move lua types converters from utils to sv1	2025-07-30 14:11:57 +03:00
Alexey	ab37ecb7f7	add init hooks to nodeApp	2025-07-30 13:47:05 +03:00
Alexey	bd02f079ab	rename sv1.HandleLUA to sv1.handleLUA	2025-07-30 12:50:12 +03:00
Alexey	b97febc16e	move lua handler to new file lua_handler.go	2025-07-30 12:39:18 +03:00
Alexey	149cfc0a17	sort imports	2025-07-30 12:38:53 +03:00
Alexey	00276dc817	add hooks/ to fmt and goimports	2025-07-30 12:34:55 +03:00
Alexey	ec2ef34f23	move initial hooks and Compositor obj to external package	2025-07-30 12:34:30 +03:00
Alexey	aebc3d2e9b	- move run hook to external package - replace own contains function to slices.Contains	2025-07-30 12:33:51 +03:00
Alexey	22ff90ca56	add db/ to .gitignore	2025-07-30 12:06:50 +03:00
Alexey	f3c4b9e9b1	update config example	2025-07-30 12:02:12 +03:00
Alexey	98d2443679	add some small changes	2025-07-30 12:00:21 +03:00
Aleksey	81359c036c	Merge pull request #1 from akyaiy/dev Dev	2025-07-29 16:51:18 +03:00