move go files to src/

2026-01-03 04:52:26 +00:00 · 2025-10-10 22:46:24 +03:00
parent f0c591f325
commit 57f35e8f33
45 changed files with 0 additions and 0 deletions
--- a/src/cmd/root.go
+++ b/src/cmd/root.go
@@ -0,0 +1,38 @@
+// The cmd package is the main package where all the main hooks and methods are called. 
+// GoSally uses spf13/cobra to organize all the calls.
+package cmd
+
+import (
+	"fmt"
+	"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/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "node",
+	Short: "Go Sally node",
+	Long: `
+GoSally is an http server that handles jsonrpc-2.0 requests by calling methods as lua 
+scripts in a given directory. For more information, visit: https://gosally.oblat.lv/`,
+	Run: func(cmd *cobra.Command, args []string) {
+		_ = cmd.Help()
+	},
+}
+
+// Execute prepares global log, loads cmdline args 
+// and executes rootCmd.Execute()
+func Execute() {
+	log.SetOutput(os.Stdout)
+	log.SetPrefix(colors.SetBrightBlack(fmt.Sprintf("(%s) ", corestate.StageNotReady)))
+	log.SetFlags(log.Ldate | log.Ltime)
+	hooks.Compositor.LoadCMDLine(rootCmd)
+	_ = rootCmd.Execute()
+	// if err := rootCmd.Execute(); err != nil {
+	// 	log.Fatalf("Unexpected error: %s", err.Error())
+	// }
+}
--- a/src/cmd/run.go
+++ b/src/cmd/run.go
@@ -0,0 +1,20 @@
+package cmd
+
+import (
+	"github.com/akyaiy/GoSally-mvp/hooks"
+	"github.com/spf13/cobra"
+)
+
+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`,
+	// hooks.Run essentially the heart of the program
+	Run: hooks.Run,
+}
+
+func init() {
+	rootCmd.AddCommand(runCmd)
+}
--- a/src/cmd/version.go
+++ b/src/cmd/version.go
@@ -0,0 +1,24 @@
+package cmd
+
+import (
+	"fmt"
+	"runtime"
+
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/spf13/cobra"
+)
+
+var verCmd = &cobra.Command{
+	Use:     "version",
+	Aliases: []string{"ver", "v"},
+	Short:   "Return node version",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Printf("GoSally node: %s\n", config.NodeVersion)
+		fmt.Printf("Go version: %s\n", runtime.Version())
+		fmt.Printf("Go OS/Arch: %s/%s\n", runtime.GOOS, runtime.GOARCH)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(verCmd)
+}
--- a/src/hooks/initial.go
+++ b/src/hooks/initial.go
@@ -0,0 +1,416 @@
+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"
+)
+
+// The config composer needs to be in the global scope
+var Compositor *config.Compositor = config.NewCompositor()
+
+func InitGlobalLoggerHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	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)
+	}
+}
+
+// The hook reads or prepares a persistent uuid for the node
+func InitUUIDHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	uuid32, err := corestate.GetNodeUUID(filepath.Join(cs.MetaDir, "uuid"))
+	if errors.Is(err, fs.ErrNotExist) {
+		if err := corestate.SetNodeUUID(filepath.Join(cs.NodePath, cs.MetaDir, cs.UUID32DirName)); err != nil {
+			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
+	corestate.NODE_UUID = uuid32
+}
+
+// The hook is responsible for checking the initialization stage 
+// and restarting in some cases
+func InitRuntimeHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	if *x.Config.Env.ParentStagePID != os.Getpid() {
+		// still pre-init stage
+		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
+// The hook creates a run.lock file, which contains information 
+// about the process and the node, in the runtime directory.
+func InitRunlockHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	NodeApp.Fallback(func(ctx context.Context, cs *corestate.CoreState, x *app.AppX) {
+		x.Log.Println("Cleaning up...")
+
+		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())
+	}
+}
+
+// The hook reads the configuration and replaces special expressions 
+// (%tmp% and so on) in string fields with the required data.
+func InitConfigReplHook(_ context.Context, cs *corestate.CoreState, x *app.AppX) {
+	if !slices.Contains(*x.Config.Conf.DisableWarnings, "--WNonStdTmpDir") && os.TempDir() != "/tmp" {
+		x.Log.Printf("%s: %s", colors.PrintWarn(), "Non-standard value specified for temporary directory")
+	}
+
+	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
+	}
+}
+
+// The hook is responsible for outputting the 
+// final config and asking for confirmation.
+func InitConfigPrintHook(ctx context.Context, cs *corestate.CoreState, x *app.AppX) {
+	if *x.Config.Conf.Node.ShowConfig {
+		fmt.Printf("Configuration from %s:\n", x.Config.CMDLine.Run.ConfigPath)
+		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
+}
+
+// The method goes through the entire config structure through 
+// reflection and replaces string fields with the required ones.
+func processConfig(conf any, replacements map[string]any) error {
+	val := reflect.ValueOf(conf)
+	if val.Kind() == reflect.Ptr {
+		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/src/hooks/run.go
+++ b/src/hooks/run.go
@@ -0,0 +1,177 @@
+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()
+var AllowedCmdPattern = `^[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*$`
+
+func Run(cmd *cobra.Command, args []string) {
+	NodeApp.InitialHooks(
+		InitGlobalLoggerHook, InitCorestateHook, InitConfigLoadHook,
+		InitUUIDHook, 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(AllowedCmdPattern),
+		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/src/internal/colors/color.go
+++ b/src/internal/colors/color.go
@@ -0,0 +1,24 @@
+package colors
+
+import "fmt"
+
+func SetBlack(s string) string   { return fmt.Sprintf("\033[30m%s\033[0m", s) }
+func SetRed(s string) string     { return fmt.Sprintf("\033[31m%s\033[0m", s) }
+func SetGreen(s string) string   { return fmt.Sprintf("\033[32m%s\033[0m", s) }
+func SetYellow(s string) string  { return fmt.Sprintf("\033[33m%s\033[0m", s) }
+func SetBlue(s string) string    { return fmt.Sprintf("\033[34m%s\033[0m", s) }
+func SetMagenta(s string) string { return fmt.Sprintf("\033[35m%s\033[0m", s) }
+func SetCyan(s string) string    { return fmt.Sprintf("\033[36m%s\033[0m", s) }
+func SetWhite(s string) string   { return fmt.Sprintf("\033[37m%s\033[0m", s) }
+
+func SetBrightBlack(s string) string   { return fmt.Sprintf("\033[90m%s\033[0m", s) }
+func SetBrightRed(s string) string     { return fmt.Sprintf("\033[91m%s\033[0m", s) }
+func SetBrightGreen(s string) string   { return fmt.Sprintf("\033[92m%s\033[0m", s) }
+func SetBrightYellow(s string) string  { return fmt.Sprintf("\033[93m%s\033[0m", s) }
+func SetBrightBlue(s string) string    { return fmt.Sprintf("\033[94m%s\033[0m", s) }
+func SetBrightMagenta(s string) string { return fmt.Sprintf("\033[95m%s\033[0m", s) }
+func SetBrightCyan(s string) string    { return fmt.Sprintf("\033[96m%s\033[0m", s) }
+func SetBrightWhite(s string) string   { return fmt.Sprintf("\033[97m%s\033[0m", s) }
+
+func PrintError() string { return SetRed("Error") }
+func PrintWarn() string  { return SetYellow("Warning") }
--- a/src/internal/core/corestate/corestate.go
+++ b/src/internal/core/corestate/corestate.go
@@ -0,0 +1,24 @@
+package corestate
+
+var NODE_UUID string
+
+type Stage string
+
+const (
+	StageNotReady Stage = "init"
+	StagePreInit  Stage = "pre-init"
+	StagePostInit Stage = "post-init"
+	StageReady    Stage = "event"
+)
+
+const (
+	StringsNone string = "none"
+)
+
+func NewCorestate(o *CoreState) *CoreState {
+	// TODO: create a convenient interface for creating a state
+	// if !utils.IsFullyInitialized(o) {
+	// 	return nil, fmt.Errorf("CoreState is not fully initialized")
+	// }
+	return o
+}
--- a/src/internal/core/corestate/node_uuid.go
+++ b/src/internal/core/corestate/node_uuid.go
@@ -0,0 +1,80 @@
+package corestate
+
+import (
+	"encoding/hex"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+)
+
+// GetNodeUUID outputs the correct uuid from the file at the path specified in the arguments.
+// If the uuid is not correct or is not exist, an empty string and an error will be returned.
+// The path to the identifier must contain the path to the "uuid" directory,
+// not the file with the identifier itself, for example: "uuid/data"
+func GetNodeUUID(metaInfPath string) (string, error) {
+	uuid, err := readNodeUUIDRaw(filepath.Join(metaInfPath, "data"))
+	if err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(uuid[:]), nil
+}
+
+func readNodeUUIDRaw(p string) ([]byte, error) {
+	data, err := os.ReadFile(p)
+	if err != nil {
+		return data, err
+	}
+	if len(data) != config.UUIDLength {
+		return data, errors.New("decoded UUID length mismatch")
+	}
+	return data, nil
+}
+
+// SetNodeUUID sets the identifier to the given path.
+// The function replaces the identifier's associated directory with all its contents.
+func SetNodeUUID(metaInfPath string) error {
+	if !strings.HasSuffix(metaInfPath, "uuid") {
+		return errors.New("invalid meta/uuid path")
+	}
+	info, err := os.Stat(metaInfPath)
+	if err == nil && info.IsDir() {
+		err = os.RemoveAll(metaInfPath)
+		if err != nil {
+			return err
+		}
+	} else if err != nil && !os.IsNotExist(err) {
+		return err
+	}
+
+	err = os.MkdirAll(metaInfPath, 0755)
+	if err != nil {
+		return err
+	}
+	dataPath := filepath.Join(metaInfPath, "data")
+
+	uuidStr, err := utils.NewUUID32Raw()
+	if err != nil {
+		return err
+	}
+
+	err = os.WriteFile(dataPath, uuidStr[:], 0644)
+	if err != nil {
+		return err
+	}
+
+	readmePath := filepath.Join(metaInfPath, "README.txt")
+	readmeContent := ` - - - - ! STRICTLY FORBIDDEN TO MODIFY THIS DIRECTORY ! - - - - 
+This directory contains the unique node identifier stored in the file named data.
+This identifier is critical for correct node recognition both locally and across the network.
+Any modification, deletion, or tampering with this directory may lead to permanent loss of identity, data corruption, or network conflicts.
+Proceed at your own risk. You have been warned.`
+	err = os.WriteFile(readmePath, []byte(readmeContent), 0644)
+	if err != nil {
+		return err
+	}
+	return nil
+}
--- a/src/internal/core/corestate/types.go
+++ b/src/internal/core/corestate/types.go
@@ -0,0 +1,24 @@
+package corestate
+
+// CoreStateContract is interface for CoreState.
+// CoreState is a structure that contains the basic meta-information vital to the node.
+// The interface contains functionality for working with the Runtime directory and its files,
+// and access to low-level logging in stdout
+type CoreStateContract interface {
+}
+
+type CoreState struct {
+	UUID32        string
+	UUID32DirName string
+
+	StartTimestampUnix int64
+
+	NodeBinName string
+	NodeVersion string
+
+	Stage Stage
+
+	NodePath string
+	MetaDir  string
+	RunDir   string
+}
--- a/src/internal/core/run_manager/run_file_manager.go
+++ b/src/internal/core/run_manager/run_file_manager.go
@@ -0,0 +1,95 @@
+package run_manager
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"syscall"
+	"time"
+)
+
+func File(index string) RunFileManagerContract {
+	value, ok := indexedPaths[index]
+	if !ok {
+		err := indexPaths()
+		if err != nil {
+			return &RunFileManager{
+				err: err,
+			}
+		}
+		value, ok = indexedPaths[index]
+		if !ok {
+			return &RunFileManager{
+				err: fmt.Errorf("cannot detect file under index %s", index),
+			}
+		}
+	}
+	return &RunFileManager{
+		indexedPath: value,
+	}
+}
+
+func (r *RunFileManager) Open() (*os.File, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	file, err := os.OpenFile(r.indexedPath, os.O_RDWR, 0)
+	if err != nil {
+		return nil, err
+	}
+	r.file = file
+	return file, nil
+}
+
+func (r *RunFileManager) Close() error {
+	return r.file.Close()
+}
+
+func (r *RunFileManager) Watch(parentCtx context.Context, callback func()) (context.CancelFunc, error) {
+	if r.err != nil {
+		return nil, r.err
+	}
+	if r.file == nil {
+		return nil, fmt.Errorf("file is not opened")
+	}
+
+	info, err := r.file.Stat()
+	if err != nil {
+		return nil, err
+	}
+	origStat := info.Sys().(*syscall.Stat_t)
+	origIno := origStat.Ino
+	origModTime := info.ModTime()
+
+	ctx, cancel := context.WithCancel(parentCtx)
+
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+				newInfo, err := os.Stat(r.indexedPath)
+				if err != nil {
+					if os.IsNotExist(err) {
+						callback()
+						return
+					}
+				} else {
+					newStat := newInfo.Sys().(*syscall.Stat_t)
+					if newStat.Ino != origIno {
+						callback()
+						return
+					}
+					if !newInfo.ModTime().Equal(origModTime) {
+						callback()
+						return
+					}
+				}
+				time.Sleep(1 * time.Second)
+			}
+		}
+	}()
+
+	return cancel, nil
+}
--- a/src/internal/core/run_manager/run_manager.go
+++ b/src/internal/core/run_manager/run_manager.go
@@ -0,0 +1,158 @@
+package run_manager
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
+)
+
+type RunManagerContract interface {
+	Get(index string) (string, error)
+
+	// Set recursively creates a file in runDir
+	Set(index string) error
+
+	File(index string) RunFileManagerContract
+
+	indexPaths() error
+}
+
+var (
+	created      bool
+	runDir       string
+	indexedPaths = make(map[string]string)
+)
+
+type RunFileManagerContract interface {
+	Open() (*os.File, error)
+	Close() error
+	Watch(parentCtx context.Context, callback func()) (context.CancelFunc, error)
+}
+
+type RunFileManager struct {
+	err         error
+	indexedPath string
+	file        *os.File
+}
+
+// func (c *CoreState) RuntimeDir() RunManagerContract {
+// 	return c.RM
+// }
+
+// Create creates a temp directory
+func Create(uuid32 string) (string, error) {
+	if created {
+		return runDir, fmt.Errorf("runtime directory is already created")
+	}
+	path, err := os.MkdirTemp("", fmt.Sprintf("*-%s-%s", uuid32, "gosally-runtime"))
+	if err != nil {
+		return "", err
+	}
+	runDir = path
+	created = true
+	return path, nil
+}
+
+func Clean() error {
+	created = false
+	indexedPaths = nil
+	return utils.CleanTempRuntimes(runDir)
+}
+
+// Quite dangerous and goofy.
+// TODO: implement a better variant of runDir indexing on the second stage of initialization
+func Toggle() string {
+	runDir = filepath.Dir(os.Args[0])
+	created = true
+	return runDir
+}
+
+func Get(index string) (string, error) {
+	if !created {
+		return "", fmt.Errorf("runtime directory is not created")
+	}
+	if indexedPaths == nil {
+		err := indexPaths()
+		if err != nil {
+			return "", nil
+		}
+	}
+	if indexedPaths == nil {
+		return "", fmt.Errorf("indexedPaths is nil")
+	}
+	value, ok := indexedPaths[index]
+	if !ok {
+		err := indexPaths()
+		if err != nil {
+			return "", err
+		}
+		value, ok = indexedPaths[index]
+		if !ok {
+			return "", fmt.Errorf("cannot detect file under index %s", index)
+		}
+	}
+	return value, nil
+}
+
+func Set(index string) error {
+	if !created {
+		return fmt.Errorf("runtime directory is not created")
+	}
+	fullPath := filepath.Join(runDir, index)
+
+	dir := filepath.Dir(fullPath)
+	err := os.MkdirAll(dir, 0755)
+	if err != nil {
+		return err
+	}
+
+	f, err := os.OpenFile(fullPath, os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	if indexedPaths == nil {
+		err = indexPaths()
+		if err != nil {
+			return err
+		}
+	} else {
+		indexedPaths[index] = fullPath
+	}
+
+	return nil
+}
+
+func SetDir(index string) error {
+	if !created {
+		return fmt.Errorf("runtime directory is not created")
+	}
+	fullPath := filepath.Join(runDir, index)
+
+	err := os.MkdirAll(fullPath, 0755)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func indexPaths() error {
+	if !created {
+		return fmt.Errorf("runtime directory is not created")
+	}
+	i, err := utils.IndexPaths(runDir)
+	if err != nil {
+		return err
+	}
+	indexedPaths = i
+	return nil
+}
+
+func RuntimeDir() string {
+	return runDir
+}
--- a/src/internal/core/update/update.go
+++ b/src/internal/core/update/update.go
@@ -0,0 +1,322 @@
+package update
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/run_manager"
+	"github.com/akyaiy/GoSally-mvp/internal/core/utils"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"golang.org/x/net/context"
+)
+
+const (
+	UpdateBranchStable  = "stable"
+	UpdateBranchDev     = "dev"
+	UpdateBranchTesting = "testing"
+)
+
+type Version string
+type Branch string
+type IsNewUpdate bool
+
+type UpdaterContract interface {
+	CkeckUpdates() (IsNewUpdate, error)
+	Update() error
+	GetCurrentVersion() (Version, Branch, error)
+	GetLatestVersion(updateBranch Branch) (Version, Branch, error)
+}
+
+type Updater struct {
+	x *app.AppX
+
+	ctx    context.Context
+	cancel context.CancelFunc
+}
+
+type UpdaterInit struct {
+	X      *app.AppX
+	Ctx    context.Context
+	Cancel context.CancelFunc
+}
+
+func NewUpdater(o *UpdaterInit) *Updater {
+	return &Updater{
+		x:      o.X,
+		ctx:    o.Ctx,
+		cancel: o.Cancel,
+	}
+}
+
+func splitVersionString(versionStr string) (Version, Branch, error) {
+	versionStr = strings.TrimSpace(versionStr)
+	if !strings.HasPrefix(versionStr, "v") {
+		return "", "unknown", errors.New("version string does not start with 'v'")
+	}
+	parts := strings.SplitN(versionStr[len("v"):], "-", 2)
+	parts[0] = strings.TrimPrefix(parts[0], "version")
+	if len(parts) != 2 {
+		return Version(parts[0]), Branch("unknown"), errors.New("version string format invalid")
+	}
+	return Version(parts[0]), Branch(parts[1]), nil
+}
+
+// isVersionNewer compares two version strings and returns true if the current version is newer than the latest version.
+func isVersionNewer(current, latest Version) bool {
+	if current == latest {
+		return false
+	}
+
+	currentParts := strings.Split(string(current), ".")
+	latestParts := strings.Split(string(latest), ".")
+
+	maxLen := len(currentParts)
+	if len(latestParts) > maxLen {
+		maxLen = len(latestParts)
+	}
+
+	for i := 0; i < maxLen; i++ {
+		var curPart, latPart int
+
+		if i < len(currentParts) {
+			cur, err := strconv.Atoi(currentParts[i])
+			if err != nil {
+				cur = 0
+			}
+			curPart = cur
+		} else {
+			curPart = 0
+		}
+
+		if i < len(latestParts) {
+			lat, err := strconv.Atoi(latestParts[i])
+			if err != nil {
+				lat = 0
+			}
+			latPart = lat
+		} else {
+			latPart = 0
+		}
+
+		if curPart < latPart {
+			return true
+		}
+		if curPart > latPart {
+			return false
+		}
+	}
+	return false
+}
+
+// GetCurrentVersion reads the current version from the version file and returns it along with the branch.
+func (u *Updater) GetCurrentVersion() (Version, Branch, error) {
+	version, branch, err := splitVersionString(string(config.NodeVersion))
+	if err != nil {
+		u.x.Log.Printf("Failed to parse version string: %s", err.Error())
+		return "", "", err
+	}
+	switch branch {
+	case UpdateBranchDev, UpdateBranchStable, UpdateBranchTesting:
+		return Version(version), Branch(branch), nil
+	default:
+		return Version(version), Branch("unknown"), nil
+	}
+}
+
+func (u *Updater) GetLatestVersion(updateBranch Branch) (Version, Branch, error) {
+	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")
+	}
+	if !strings.HasPrefix(repoURL, "http://") && !strings.HasPrefix(repoURL, "https://") {
+		u.x.Log.Printf("Failed to get latest version: %s: %s", "RepositoryURL does not start with http:// or https:/", repoURL)
+		return "", "", errors.New("repository URL must start with http:// or https://")
+	}
+	response, err := http.Get(repoURL + "/" + config.ActualFileName)
+	if err != nil {
+		u.x.Log.Printf("Failed to fetch latest version: %s", err.Error())
+		return "", "", err
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		u.x.Log.Printf("Failed to fetch latest version: HTTP status %d", response.StatusCode)
+		return "", "", errors.New("failed to fetch latest version, status code: " + http.StatusText(response.StatusCode))
+	}
+	data, err := io.ReadAll(response.Body)
+	if err != nil {
+		u.x.Log.Printf("Failed to read latest version response: %s", err.Error())
+		return "", "", err
+	}
+	lines := strings.Split(string(data), "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		version, branch, err := splitVersionString(string(line))
+		if err != nil {
+			u.x.Log.Printf("Failed to parse version string: %s", err.Error())
+			return "", "", err
+		}
+		if branch == updateBranch {
+			return Version(version), Branch(branch), nil
+		}
+	}
+	return "", "", errors.New("no version found for branch: " + string(updateBranch))
+}
+
+func (u *Updater) CkeckUpdates() (IsNewUpdate, error) {
+	currentVersion, currentBranch, err := u.GetCurrentVersion()
+	if err != nil {
+		return false, err
+	}
+	latestVersion, latestBranch, err := u.GetLatestVersion(currentBranch)
+	if err != nil {
+		return false, err
+	}
+	if currentVersion == latestVersion && currentBranch == latestBranch {
+		return false, nil
+	}
+	return true, nil
+}
+
+func (u *Updater) Update() error {
+	if !*u.x.Config.Conf.Updates.UpdatesEnabled {
+		return errors.New("updates are disabled in config, skipping update")
+	}
+
+	if err := run_manager.SetDir("update"); err != nil {
+		return fmt.Errorf("failed to create update dir: %w", err)
+	}
+
+	downloadPath := filepath.Join(run_manager.RuntimeDir(), "update")
+
+	_, currentBranch, err := u.GetCurrentVersion()
+	if err != nil {
+		return fmt.Errorf("failed to get current version: %w", err)
+	}
+	latestVersion, latestBranch, err := u.GetLatestVersion(currentBranch)
+	if err != nil {
+		return fmt.Errorf("failed to get latest version: %w", err)
+	}
+
+	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")
+
+	resp, err := http.Get(updateDest)
+	if err != nil {
+		return fmt.Errorf("failed to fetch archive: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("unexpected HTTP status: %s, body: %s", resp.Status, body)
+	}
+
+	gzReader, err := gzip.NewReader(resp.Body)
+	if err != nil {
+		return fmt.Errorf("gzip reader error: %w", err)
+	}
+	defer gzReader.Close()
+
+	tarReader := tar.NewReader(gzReader)
+	for {
+		header, err := tarReader.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("tar read error: %w", err)
+		}
+
+		relativeParts := strings.SplitN(header.Name, string(os.PathSeparator), 2)
+		if len(relativeParts) < 2 {
+			// It's either a top level directory or garbage.
+			continue
+		}
+		cleanName := relativeParts[1]
+		targetPath := filepath.Join(downloadPath, cleanName)
+
+		switch header.Typeflag {
+		case tar.TypeDir:
+			if err := os.MkdirAll(targetPath, os.FileMode(header.Mode)); err != nil {
+				return fmt.Errorf("mkdir error: %w", err)
+			}
+		case tar.TypeReg:
+			if err := run_manager.Set(filepath.Join("update", cleanName)); err != nil {
+				return fmt.Errorf("set file error: %w", err)
+			}
+			f := run_manager.File(filepath.Join("update", cleanName))
+			outFile, err := f.Open()
+			if err != nil {
+				return fmt.Errorf("open file error: %w", err)
+			}
+			if _, err := io.Copy(outFile, tarReader); err != nil {
+				outFile.Close()
+				return fmt.Errorf("copy file error: %w", err)
+			}
+			outFile.Close()
+		default:
+			return fmt.Errorf("unsupported tar type: %v", header.Typeflag)
+		}
+	}
+
+	return u.InstallAndRestart()
+}
+
+func (u *Updater) InstallAndRestart() error {
+
+	nodePath := *u.x.Config.Env.NodePath
+	if nodePath == "" {
+		return errors.New("GS_NODE_PATH environment variable is not set")
+	}
+	installDir := filepath.Join(nodePath, "bin")
+	targetPath := filepath.Join(installDir, "node")
+
+	f := run_manager.File("update/node")
+	input, err := f.Open()
+	if err != nil {
+		return fmt.Errorf("cannot open new binary: %w", err)
+	}
+	defer f.Close()
+
+	output, err := os.Create(targetPath)
+	if err != nil {
+		return fmt.Errorf("cannot create target binary: %w", err)
+	}
+	if _, err := io.Copy(output, input); err != nil {
+		output.Close()
+		return fmt.Errorf("copy failed: %w", err)
+	}
+	output.Close()
+
+	if err := os.Chmod(targetPath, 0755); err != nil {
+		return fmt.Errorf("failed to chmod: %w", err)
+	}
+
+	u.x.Log.Printf("Launching new version: path is %s", targetPath)
+	args := os.Args
+	args[0] = targetPath
+	env := utils.SetEviron(os.Environ(), "GS_PARENT_PID=-1")
+
+	if err := run_manager.Clean(); err != nil {
+		return err
+	}
+	return syscall.Exec(targetPath, args, env)
+}
+
+func (u *Updater) Shutdownfunc(f context.CancelFunc) {
+	u.cancel = f
+}
--- a/src/internal/core/update/update_test.go
+++ b/src/internal/core/update/update_test.go
@@ -0,0 +1,30 @@
+package update
+
+import (
+	"testing"
+)
+
+func TestFunc_isVersionNewer(t *testing.T) {
+	tests := []struct {
+		current string
+		latest  string
+		want    bool
+	}{
+		{"1.0.0", "1.0.0", false},
+		{"1.0.0", "1.0.1", true},
+		{"1.0.1", "1.0.0", false},
+		{"2.0.0", "1.9.9", false},
+		{"2.2.3", "1.9.9", false},
+		{"22.2.3", "1.9.9", false},
+		{"1.2.3", "1.99.9", true},
+		{"1.10", "1.5.99999", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.current+" vs "+tt.latest, func(t *testing.T) {
+			if got := isVersionNewer(Version(tt.current), Version(tt.latest)); got != tt.want {
+				t.Errorf("isVersionNewer(%q, %q) = %v; want %v", tt.current, tt.latest, got, tt.want)
+			}
+		})
+	}
+}
--- a/src/internal/core/utils/http_errors.go
+++ b/src/internal/core/utils/http_errors.go
@@ -0,0 +1,22 @@
+package utils
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// writeJSONError writes a JSON error response to the HTTP response writer.
+// It sets the Content-Type to application/json, writes the specified HTTP status code
+func WriteJSONError(w http.ResponseWriter, status int, msg string) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	resp := map[string]any{
+		"status": "error",
+		"error":  msg,
+		"code":   status,
+	}
+	if err := json.NewEncoder(w).Encode(resp); err != nil {
+		return err
+	}
+	return nil
+}
--- a/src/internal/core/utils/panic.go
+++ b/src/internal/core/utils/panic.go
@@ -0,0 +1,34 @@
+package utils
+
+import (
+	"log"
+	"runtime"
+
+	"golang.org/x/net/context"
+)
+
+func CatchPanic() {
+	if err := recover(); err != nil {
+		stack := make([]byte, 8096)
+		stack = stack[:runtime.Stack(stack, false)]
+		log.Printf("recovered panic:\n%s", stack)
+	}
+}
+
+func CatchPanicWithCancel(cancel context.CancelFunc) {
+	if err := recover(); err != nil {
+		stack := make([]byte, 8096)
+		stack = stack[:runtime.Stack(stack, false)]
+		log.Printf("recovered panic:\n%s", stack)
+		cancel()
+	}
+}
+
+func CatchPanicWithFallback(onPanic func(any)) {
+	if err := recover(); err != nil {
+		stack := make([]byte, 8096)
+		stack = stack[:runtime.Stack(stack, false)]
+		log.Printf("recovered panic:\n%s", stack)
+		onPanic(err)
+	}
+}
--- a/src/internal/core/utils/routines.go
+++ b/src/internal/core/utils/routines.go
@@ -0,0 +1,122 @@
+package utils
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+)
+
+func SetEviron(eviron []string, envs ...string) []string {
+	envMap := make(map[string]string)
+	for _, e := range eviron {
+		parts := strings.SplitN(e, "=", 2)
+		if len(parts) == 2 {
+			envMap[parts[0]] = parts[1]
+		}
+	}
+	for _, e := range envs {
+		parts := strings.SplitN(e, "=", 2)
+		if len(parts) == 2 {
+			envMap[parts[0]] = parts[1]
+		}
+	}
+	newEviron := make([]string, 0, len(envMap))
+	for k, v := range envMap {
+		newEviron = append(newEviron, fmt.Sprintf("%s=%s", k, v))
+	}
+
+	return newEviron
+}
+func CleanTempRuntimes(pattern string) error {
+	matches, err := filepath.Glob(pattern)
+	if err != nil {
+		return err
+	}
+
+	for _, path := range matches {
+		info, err := os.Stat(path)
+		if err != nil {
+			continue
+		}
+		if info.IsDir() {
+			os.RemoveAll(path)
+		}
+	}
+	return nil
+}
+
+func ExistsMatchingDirs(pattern, exclude string) (bool, error) {
+	matches, err := filepath.Glob(pattern)
+	if err != nil {
+		return false, err
+	}
+
+	for _, path := range matches {
+		if filepath.Clean(path) == filepath.Clean(exclude) {
+			continue
+		}
+		info, err := os.Stat(path)
+		if err == nil && info.IsDir() {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func IndexPaths(runDir string) (map[string]string, error) {
+	indexed := make(map[string]string)
+
+	err := filepath.Walk(runDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if info.IsDir() {
+			return nil
+		}
+
+		relPath, err := filepath.Rel(runDir, path)
+		if err != nil {
+			return err
+		}
+
+		indexed[relPath] = path
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return indexed, nil
+}
+
+func IsFullyInitialized(i any) bool {
+	v := reflect.ValueOf(i).Elem()
+
+	for i := 0; i < v.NumField(); i++ {
+		field := v.Field(i)
+
+		switch field.Kind() {
+		case reflect.Ptr, reflect.Slice, reflect.Map, reflect.Chan, reflect.Func:
+			if field.IsNil() {
+				return false
+			}
+		case reflect.String:
+			if field.String() == "" {
+				return false
+			}
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			if field.Int() == 0 {
+				return false
+			}
+		case reflect.Bool:
+			if !field.Bool() {
+				return false
+			}
+		}
+	}
+	return true
+}
--- a/src/internal/core/utils/safe_fetch.go
+++ b/src/internal/core/utils/safe_fetch.go
@@ -0,0 +1,9 @@
+package utils
+
+// SafeFetch safely fetches data. If v = nil, a fallback value is returned.
+func SafeFetch[T any](v *T, fallback T) T {
+	if v == nil {
+		return fallback
+	}
+	return *v
+}
--- a/src/internal/core/utils/utils_test.go
+++ b/src/internal/core/utils/utils_test.go
@@ -0,0 +1,48 @@
+package utils
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func TestFunc_SetEviron(t *testing.T) {
+	tests := []struct {
+		eviron []string
+		envs   []string
+		want   []string
+	}{
+		{
+			[]string{"ENV1=1", "ENV2=2", "ENV3=4"},
+			[]string{"ENV3=3"},
+			[]string{"ENV1=1", "ENV2=2", "ENV3=3"},
+		},
+		{
+			[]string{"ENV1=1", "ENV2=5", "ENV3=4"},
+			[]string{"ENV2=2", "ENV3=3"},
+			[]string{"ENV1=1", "ENV2=2", "ENV3=3"},
+		},
+		{
+			[]string{"ENV1=1", "ENV2=2", "ENV3=3"},
+			[]string{"ENV4=4"},
+			[]string{"ENV1=1", "ENV2=2", "ENV3=3", "ENV4=4"},
+		},
+		{
+			[]string{"ENV1=1", "ENV2=2", "ENV3=4"},
+			[]string{"ENV3=2", "ENV3=3"},
+			[]string{"ENV1=1", "ENV2=2", "ENV3=3"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf("in %q set new %q", tt.eviron, tt.envs), func(t *testing.T) {
+			got := SetEviron(tt.eviron, tt.envs...)
+			sort.Strings(got)
+			sort.Strings(tt.want)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("SetEviron(%q, %q) = got %v; want %v", tt.eviron, tt.envs, got, tt.want)
+			}
+		})
+	}
+}
--- a/src/internal/core/utils/uuid.go
+++ b/src/internal/core/utils/uuid.go
@@ -0,0 +1,41 @@
+package utils
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+)
+
+func NewUUIDRaw(length int) ([]byte, error) {
+	bytes := make([]byte, int(length))
+	_, err := rand.Read(bytes)
+	if err != nil {
+		return bytes, errors.New("failed to generate UUID: " + err.Error())
+	}
+	return bytes, nil
+}
+
+func NewUUID(length int) (string, error) {
+	data, err := NewUUIDRaw(length)
+	if err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(data), nil
+}
+
+func NewUUID32() (string, error) {
+	return NewUUID(config.UUIDLength)
+}
+
+func NewUUID32Raw() ([]byte, error) {
+	data, err := NewUUIDRaw(config.UUIDLength)
+	if err != nil {
+		return data, err
+	}
+	if len(data) != config.UUIDLength {
+		return data, errors.New("unexpected UUID length")
+	}
+	return data, nil
+}
--- a/src/internal/engine/app/app.go
+++ b/src/internal/engine/app/app.go
@@ -0,0 +1,95 @@
+package app
+
+import (
+	"context"
+	"log"
+	"log/slog"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+)
+
+type AppContract interface {
+	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))
+
+	CallFallback(ctx context.Context)
+}
+
+type App struct {
+	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)
+
+	Corestate *corestate.CoreState
+	AppX      *AppX
+
+	fallbackOnce sync.Once
+}
+
+type AppX struct {
+	Config *config.Compositor
+	Log    *log.Logger
+	SLog   *slog.Logger
+}
+
+func New() AppContract {
+	return &App{
+		AppX: &AppX{
+			Log: log.Default(),
+		},
+		Corestate: &corestate.CoreState{},
+	}
+}
+
+func (a *App) InitialHooks(fn ...func(ctx context.Context, cs *corestate.CoreState, x *AppX)) {
+	a.initHooks = append(a.initHooks, fn...)
+}
+
+func (a *App) Fallback(fn func(ctx context.Context, cs *corestate.CoreState, x *AppX)) {
+	a.fallback = fn
+}
+
+func (a *App) Run(fn func(ctx context.Context, cs *corestate.CoreState, x *AppX) error) {
+	a.runHook = fn
+
+	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)
+			if a.fallback != nil {
+				a.fallback(ctx, a.Corestate, a.AppX)
+			}
+			os.Exit(1)
+		}
+	}()
+
+	var runErr error
+	if a.runHook != nil {
+		runErr = a.runHook(ctx, a.Corestate, a.AppX)
+	}
+
+	if runErr != nil {
+		a.AppX.Log.Fatalf("fatal in Run: %v", runErr)
+	}
+}
+
+func (a *App) CallFallback(ctx context.Context) {
+	a.fallbackOnce.Do(func() {
+		if a.fallback != nil {
+			a.fallback(ctx, a.Corestate, a.AppX)
+		}
+		os.Exit(0)
+	})
+}
--- a/src/internal/engine/config/compositor.go
+++ b/src/internal/engine/config/compositor.go
@@ -0,0 +1,186 @@
+package config
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+func NewCompositor() *Compositor {
+	return &Compositor{}
+}
+
+func (c *Compositor) LoadEnv() error {
+	v := viper.New()
+
+	// defaults
+	v.SetDefault("config_path", "./cfg/config.yaml")
+	v.SetDefault("node_path", "./")
+	v.SetDefault("parent_pid", -1)
+
+	// GS_*
+	v.SetEnvPrefix("GS")
+	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
+	v.AutomaticEnv()
+
+	var env Env
+	if err := v.Unmarshal(&env); err != nil {
+		return fmt.Errorf("error unmarshaling env: %w", err)
+	}
+
+	c.Env = &env
+	return nil
+}
+
+func (c *Compositor) LoadConf(path string) error {
+	v := viper.New()
+
+	v.SetConfigFile(path)
+	v.SetConfigType("yaml")
+
+	// defaults
+	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)
+	v.SetDefault("tls.cert_file", "./cert/server.crt")
+	v.SetDefault("tls.key_file", "./cert/server.key")
+	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.output", "%2%")
+
+	if err := v.ReadInConfig(); err != nil {
+		return fmt.Errorf("error reading config: %w", err)
+	}
+
+	var cfg Conf
+	if err := v.Unmarshal(&cfg); err != nil {
+		return fmt.Errorf("error unmarshaling config: %w", err)
+	}
+
+	c.Conf = &Conf{}
+	c.Conf = &cfg
+	return nil
+}
+
+func (c *Compositor) LoadCMDLine(root *cobra.Command) {
+	cmdLine := &CMDLine{}
+	c.CMDLine = cmdLine
+
+	t := reflect.TypeOf(cmdLine).Elem()
+	v := reflect.ValueOf(cmdLine).Elem()
+
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		fieldVal := v.Field(i)
+		ptr := fieldVal.Addr().Interface()
+		use := strings.ToLower(field.Name)
+
+		var cmd *cobra.Command
+		for _, sub := range root.Commands() {
+
+			if sub.Use == use {
+				cmd = sub
+				break
+			}
+		}
+
+		if use == root.Use {
+			cmd = root
+		}
+
+		if cmd == nil {
+			continue
+		}
+
+		Unmarshal(cmd, ptr)
+	}
+}
+
+func Unmarshal(cmd *cobra.Command, target any) {
+	t := reflect.TypeOf(target).Elem()
+	v := reflect.ValueOf(target).Elem()
+
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		valPtr := v.Field(i).Addr().Interface()
+
+		full := field.Tag.Get("full")
+		short := field.Tag.Get("short")
+		def := field.Tag.Get("def")
+		desc := field.Tag.Get("desc")
+		isPersistent := field.Tag.Get("persistent") == "true"
+
+		flagSet := cmd.Flags()
+		if isPersistent {
+			flagSet = cmd.PersistentFlags()
+		}
+
+		switch field.Type.Kind() {
+		case reflect.String:
+			flagSet.StringVarP(valPtr.(*string), full, short, def, desc)
+
+		case reflect.Bool:
+			defVal, err := strconv.ParseBool(def)
+			if err != nil && def != "" {
+				fmt.Printf("warning: cannot parse default bool: %q\n", def)
+			}
+			flagSet.BoolVarP(valPtr.(*bool), full, short, defVal, desc)
+
+		case reflect.Int:
+			defVal, err := strconv.Atoi(def)
+			if err != nil && def != "" {
+				fmt.Printf("warning: cannot parse default int: %q\n", def)
+			}
+			flagSet.IntVarP(valPtr.(*int), full, short, defVal, desc)
+
+		case reflect.Slice:
+			elemKind := field.Type.Elem().Kind()
+			switch elemKind {
+			case reflect.String:
+				defVals := []string{}
+				if def != "" {
+					defVals = strings.Split(def, ",")
+				}
+				flagSet.StringSliceVarP(valPtr.(*[]string), full, short, defVals, desc)
+
+			case reflect.Int:
+				var intVals []int
+				if def != "" {
+					for _, s := range strings.Split(def, ",") {
+						s = strings.TrimSpace(s)
+						if s == "" {
+							continue
+						}
+						n, err := strconv.Atoi(s)
+						if err != nil {
+							fmt.Printf("warning: cannot parse int in slice: %q\n", s)
+							continue
+						}
+						intVals = append(intVals, n)
+					}
+				}
+				flagSet.IntSliceVarP(valPtr.(*[]int), full, short, intVals, desc)
+
+			default:
+				fmt.Printf("unsupported slice element type: %s\n", elemKind)
+			}
+
+		default:
+			fmt.Printf("unsupported field type: %s\n", field.Type.Kind())
+		}
+	}
+}
--- a/src/internal/engine/config/config.go
+++ b/src/internal/engine/config/config.go
@@ -0,0 +1,82 @@
+// Package config provides configuration management for the application.
+// config is built on top of the third-party module cleanenv
+package config
+
+import (
+	"time"
+)
+
+type CompositorContract interface {
+	LoadEnv() error
+	LoadConf(path string) error
+}
+
+type Compositor struct {
+	CMDLine *CMDLine
+	Conf    *Conf
+	Env     *Env
+}
+
+type Conf struct {
+	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"`
+	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"`
+}
+
+type Updates struct {
+	UpdatesEnabled *bool          `mapstructure:"enabled"`
+	CheckInterval  *time.Duration `mapstructure:"check_interval"`
+	RepositoryURL  *string        `mapstructure:"repository_url"`
+	WantedVersion  *string        `mapstructure:"wanted_version"`
+}
+
+type Log struct {
+	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"`
+}
+
+type CMDLine struct {
+	Run  Run
+	Node Root
+}
+
+type Root struct {
+	Debug bool `persistent:"true" full:"debug" short:"d" def:"false" desc:"Set debug mode"`
+}
+
+type Run struct {
+	ConfigPath string `persistent:"true" full:"config" short:"c" def:"./config.yaml" desc:"Path to configuration file"`
+	Test       []int  `persistent:"true" full:"test" short:"t" def:"" desc:"js test"`
+}
--- a/src/internal/engine/config/consts.go
+++ b/src/internal/engine/config/consts.go
@@ -0,0 +1,36 @@
+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
+
+// ApiRoute setting for go-chi for main route for api requests
+var ApiRoute string = "/api/{ver}"
+
+// ComDirRoute setting for go-chi for main route for commands
+var ComDirRoute string = "/com"
+
+// NodeVersion is the version of the node. It can be set by the build system or manually.
+// If not set, it will return "version0.0.0-none" by default
+var NodeVersion string
+
+// ActualFileName is a feature of the GoSally update system.
+// In the repository, the file specified in the variable contains the current information about updates
+var ActualFileName string = "actual.txt"
+
+// UpdateArchiveName is the name of the archive that will be used for updates.
+var UpdateArchiveName string = "gosally-node"
+
+// UpdateInstallPath is the path where the update will be installed.
+var UpdateDownloadPath string = os.TempDir()
+
+var MetaDir string = "./.meta"
+
+func init() {
+	if NodeVersion == "" {
+		NodeVersion = "v0.0.0-none"
+	}
+}
--- a/src/internal/engine/config/print.go
+++ b/src/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/src/internal/engine/logs/logger.go
+++ b/src/internal/engine/logs/logger.go
@@ -0,0 +1,85 @@
+// Package logs provides a logger setup function that configures the logger based on the environment.
+// It supports different logging levels for development and production environments.
+// It uses the standard library's slog package for structured logging.
+package logs
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"log/slog"
+	"os"
+	"path/filepath"
+
+	"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
+}
+
+func (w *SlogWriter) Write(p []byte) (n int, err error) {
+	msg := string(bytes.TrimSpace(p))
+	w.Logger.Log(context.TODO(), w.Level, msg)
+	return len(p), nil
+}
+
+// SetupLogger initializes and returns a logger based on the provided environment.
+func SetupLogger(o *config.Log) (*slog.Logger, error) {
+	var handlerOpts = slog.HandlerOptions{}
+	var writer io.Writer = os.Stdout
+
+	switch *o.Level {
+	case "debug":
+		GlobalLevel = slog.LevelDebug
+		handlerOpts.Level = slog.LevelDebug
+	case "info":
+		GlobalLevel = slog.LevelInfo
+		handlerOpts.Level = slog.LevelInfo
+	default:
+		GlobalLevel = slog.LevelInfo
+		handlerOpts.Level = slog.LevelInfo
+	}
+
+	switch *o.OutPath {
+	case "_1STDout":
+		writer = os.Stdout
+	case "_2STDerr":
+		writer = os.Stderr
+	default:
+		logFile := &lumberjack.Logger{
+			Filename:   filepath.Join(*o.OutPath, "event.log"),
+			MaxSize:    10,
+			MaxBackups: 5,
+			MaxAge:     28,
+			Compress:   true,
+		}
+		writer = logFile
+	}
+
+	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/src/internal/engine/logs/mock.go
+++ b/src/internal/engine/logs/mock.go
@@ -0,0 +1,25 @@
+package logs
+
+import (
+	"context"
+	"log/slog"
+	"sync"
+)
+
+// MockHandler is a mock implementation of slog.Handler for testing purposes.
+type MockHandler struct {
+	mu sync.Mutex
+	// Logs stores the log records captured by the handler.
+	Logs []slog.Record
+}
+
+func NewMockHandler() *MockHandler                                  { return &MockHandler{} }
+func (h *MockHandler) Enabled(_ context.Context, _ slog.Level) bool { return true }
+func (h *MockHandler) WithAttrs(_ []slog.Attr) slog.Handler         { return h }
+func (h *MockHandler) WithGroup(_ string) slog.Handler              { return h }
+func (h *MockHandler) Handle(_ context.Context, r slog.Record) error {
+	h.mu.Lock()
+	defer h.mu.Unlock()
+	h.Logs = append(h.Logs, r.Clone())
+	return nil
+}
--- a/src/internal/engine/lua/handler.go
+++ b/src/internal/engine/lua/handler.go
@@ -0,0 +1 @@
+package lua
--- a/src/internal/engine/lua/pool.go
+++ b/src/internal/engine/lua/pool.go
@@ -0,0 +1,35 @@
+package lua
+
+import (
+	"sync"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+type LuaPool struct {
+	pool sync.Pool
+}
+
+func NewLuaPool() *LuaPool {
+	return &LuaPool{
+		pool: sync.Pool{
+			New: func() any {
+				L := lua.NewState()
+				
+				return L
+			},
+		},
+	}
+}
+
+func (lp *LuaPool) Get() *lua.LState {
+	return lp.pool.Get().(*lua.LState)
+}
+
+func (lp *LuaPool) Put(L *lua.LState) {
+	L.Close()
+
+	newL := lua.NewState()
+	
+	lp.pool.Put(newL)
+}
--- a/src/internal/engine/lua/types.go
+++ b/src/internal/engine/lua/types.go
@@ -0,0 +1,26 @@
+package lua
+
+import (
+	"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"
+)
+
+type LuaEngineDeps struct {
+	HttpRequest    *http.Request
+	JSONRPCRequest *rpc.RPCRequest
+	SessionUUID string
+	ScriptPath string
+}
+
+type LuaEngineContract interface {
+	Handle(deps *LuaEngineDeps) *rpc.RPCResponse
+	
+}
+
+type LuaEngine struct {
+	x  *app.AppX
+	cs *corestate.CoreState
+}
--- a/src/internal/server/gateway/general_types.go
+++ b/src/internal/server/gateway/general_types.go
@@ -0,0 +1,30 @@
+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.
+type serversApiVer string
+
+type ServerApiContract interface {
+	GetVersion() string
+	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.
+type GatewayServer struct {
+	// servers holds the registered servers by their API version.
+	// 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/src/internal/server/gateway/init.go
+++ b/src/internal/server/gateway/init.go
@@ -0,0 +1,47 @@
+package gateway
+
+import (
+	"errors"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
+	"github.com/akyaiy/GoSally-mvp/internal/server/session"
+)
+
+// GeneralServerInit structure only for initialization general server.
+type GatewayServerInit struct {
+	SM *session.SessionManager
+	CS *corestate.CoreState
+	X  *app.AppX
+}
+
+// InitGeneral initializes a new GeneralServer with the provided configuration and registered servers.
+func InitGateway(o *GatewayServerInit, servers ...ServerApiContract) *GatewayServer {
+	general := &GatewayServer{
+		servers: make(map[serversApiVer]ServerApiContract),
+		sm:      o.SM,
+		cs:      o.CS,
+		x:       o.X,
+	}
+
+	// register the provided servers
+	// s is each server implementing GeneralServerApiContract, this is not a general server
+	for _, s := range servers {
+		general.servers[serversApiVer(s.GetVersion())] = s
+	}
+	return general
+}
+
+// GetVersion returns the API version of the GeneralServer, which is "general".
+func (s *GatewayServer) GetVersion() string {
+	return "general"
+}
+
+// AppendToArray adds a new server to the GeneralServer's internal map.
+func (s *GatewayServer) AppendToArray(server ServerApiContract) error {
+	if _, exist := s.servers[serversApiVer(server.GetVersion())]; !exist {
+		s.servers[serversApiVer(server.GetVersion())] = server
+		return nil
+	}
+	return errors.New("server with this version is already exist")
+}
--- a/src/internal/server/gateway/route.go
+++ b/src/internal/server/gateway/route.go
@@ -0,0 +1,114 @@
+package gateway
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"sync"
+
+	"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.NewError(rpc.ErrSessionIsBusy, rpc.ErrSessionIsBusyS, nil, nil))
+		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.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, nil))
+		gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInternalErrorS))
+		return
+	}
+
+	// determine if the JSON-RPC request is a batch
+	var batch []rpc.RPCRequest
+	json.Unmarshal(body, &batch)
+	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.NewError(rpc.ErrParseError, rpc.ErrParseErrorS, nil, nil))
+			gs.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrParseErrorS))
+			return
+		}
+		resp := gs.Route(ctx, sessionUUID, r, &single)
+		if resp == nil {
+			w.Write([]byte(""))
+			return
+		}
+		rpc.WriteResponse(w, resp)
+		return
+	}
+
+	// handle batch
+	responses := make(chan rpc.RPCResponse, len(batch))
+	var wg sync.WaitGroup
+	for _, m := range batch {
+		wg.Add(1)
+		go func(req rpc.RPCRequest) {
+			defer wg.Done()
+			res := gs.Route(ctx, sessionUUID, r, &req)
+			if res != nil {
+				responses <- *res
+			}
+		}(m)
+	}
+	wg.Wait()
+	close(responses)
+
+	var result []rpc.RPCResponse
+	for res := range responses {
+		result = append(result, res)
+	}
+	if len(result) > 0 {
+		json.NewEncoder(w).Encode(result)
+	} else {
+		w.Write([]byte("[]"))
+	}
+}
+
+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)", 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, 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, nil, req.ID)
+	}
+
+	// checks if request is notification
+	if req.ID == nil {
+		go server.Handle(ctx, sid, r, req)
+		return nil
+	}
+	return server.Handle(ctx, sid, r, req)
+}
--- a/src/internal/server/rpc/definition.go
+++ b/src/internal/server/rpc/definition.go
@@ -0,0 +1,30 @@
+package rpc
+
+import "encoding/json"
+
+type RPCRequest struct {
+	JSONRPC        string           `json:"jsonrpc"`
+	ID             *json.RawMessage `json:"id,omitempty"`
+	Method         string           `json:"method"`
+	Params         any              `json:"params,omitempty"`
+	ContextVersion string           `json:"context-version,omitempty"`
+}
+
+type RPCResponse struct {
+	JSONRPC string           `json:"jsonrpc"`
+	ID      *json.RawMessage `json:"id"`
+	Result  any              `json:"result,omitzero"`
+	Error   any              `json:"error,omitzero"`
+	Data    *RPCData         `json:"data,omitzero"`
+}
+
+type RPCData struct {
+	ResponsibleNode string `json:"responsible-node,omitempty"`
+	Salt            string `json:"salt,omitempty"`
+	Checksum        string `json:"checksum-md5,omitempty"`
+	NewSessionUUID  string `json:"new-session-uuid,omitempty"`
+}
+
+const (
+	JSONRPCVersion = "2.0"
+)
--- a/src/internal/server/rpc/errors.go
+++ b/src/internal/server/rpc/errors.go
@@ -0,0 +1,30 @@
+package rpc
+
+const (
+	ErrParseError  = -32700
+	ErrParseErrorS = "Parse error"
+
+	ErrInvalidRequest  = -32600
+	ErrInvalidRequestS = "Invalid Request"
+
+	ErrMethodNotFound  = -32601
+	ErrMethodNotFoundS = "Method not found"
+
+	ErrInvalidParams  = -32602
+	ErrInvalidParamsS = "Invalid params"
+
+	ErrInternalError  = -32603
+	ErrInternalErrorS = "Internal error"
+
+	ErrContextVersion  = -32010
+	ErrContextVersionS = "Invalid context version"
+
+	ErrInvalidMethodFormat  = -32020
+	ErrInvalidMethodFormatS = "Invalid method format"
+
+	ErrMethodIsMissing  = -32020
+	ErrMethodIsMissingS = "Method is missing"
+
+	ErrSessionIsBusy  = -32030
+	ErrSessionIsBusyS = "The session is busy"
+)
--- a/src/internal/server/rpc/responsers.go
+++ b/src/internal/server/rpc/responsers.go
@@ -0,0 +1,60 @@
+package rpc
+
+import (
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/google/uuid"
+)
+
+func generateChecksum(result any) string {
+	if result == nil {
+		return ""
+	}
+	data, err := json.Marshal(result)
+	if err != nil {
+		return ""
+	}
+	return fmt.Sprintf("%x", md5.Sum(data))
+}
+
+func generateSalt() string {
+	return uuid.NewString()
+}
+
+func GetData(data any) *RPCData {
+	return &RPCData{
+		Salt:            generateSalt(),
+		ResponsibleNode: corestate.NODE_UUID,
+		Checksum:        generateChecksum(data),
+	}
+}
+
+func NewError(code int, message string, data any, id *json.RawMessage) *RPCResponse {
+	Error := make(map[string]any)
+	Error = map[string]any{
+		"code":    code,
+		"message": message,
+	}
+	if data != nil {
+		Error["data"] = data
+	}
+
+	return &RPCResponse{
+		JSONRPC: JSONRPCVersion,
+		ID:      id,
+		Error:   Error,
+		Data:    GetData(Error),
+	}
+}
+
+func NewResponse(result any, id *json.RawMessage) *RPCResponse {
+	return &RPCResponse{
+		JSONRPC: JSONRPCVersion,
+		ID:      id,
+		Result:  result,
+		Data:    GetData(result),
+	}
+}
--- a/src/internal/server/rpc/writers.go
+++ b/src/internal/server/rpc/writers.go
@@ -0,0 +1,23 @@
+package rpc
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func write(w http.ResponseWriter, msg *RPCResponse) error {
+	data, err := json.Marshal(msg)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(data)
+	return err
+}
+
+func WriteError(w http.ResponseWriter, errm *RPCResponse) error {
+	return write(w, errm)
+}
+
+func WriteResponse(w http.ResponseWriter, response *RPCResponse) error {
+	return write(w, response)
+}
--- a/src/internal/server/session/manager.go
+++ b/src/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/src/internal/server/sv1/db_sqlite.go
+++ b/src/internal/server/sv1/db_sqlite.go
@@ -0,0 +1,415 @@
+package sv1
+
+import (
+	"database/sql"
+	"fmt"
+	"log/slog"
+	"sync"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+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, sid string) func(*lua.LState) int {
+	return func(L *lua.LState) int {
+		llog.Debug("import module db-sqlite")
+		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,
+			"query_row": dbQueryRow,
+			"close": dbClose,
+		}))
+
+		L.SetField(dbMod, "__seed", lua.LString(sid))
+		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(L *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 {
+			L.Push(lua.LNil)
+			L.Push(lua.LString(res.err.Error()))
+			return 2
+		}
+		L.Push(lua.LNumber(res.rowsAffected))
+		L.Push(lua.LNil)
+		return 2
+	}))
+
+	L.SetField(ctx, "check", L.NewFunction(func(L *lua.LState) int {
+		select {
+		case res := <-resCh:
+			L.SetField(ctx, "done", lua.LBool(true))
+			if res.err != nil {
+				errorMsg = lua.LString(res.err.Error())
+				result = lua.LNil
+				L.Push(lua.LNil)
+				L.Push(lua.LString(res.err.Error()))
+				return 2
+			} else {
+				result = lua.LNumber(res.rowsAffected)
+				errorMsg = lua.LNil
+				L.Push(lua.LNumber(res.rowsAffected))
+				L.Push(lua.LNil)
+				return 2
+			}
+		default:
+			L.Push(result)
+			L.Push(errorMsg)
+			return 2
+		}
+	}))
+
+	L.Push(ctx)
+	L.Push(lua.LNil)
+	return 2
+}
+
+func dbQueryRow(L *lua.LState) int {
+    ud := L.CheckUserData(1)
+    conn, ok := ud.Value.(*DBConnection)
+    if !ok {
+        L.Push(lua.LNil)
+        L.Push(lua.LString("invalid database connection"))
+        return 2
+    }
+
+    query := L.CheckString(2)
+
+    var args []any
+    if L.GetTop() >= 3 {
+        params := L.CheckTable(3)
+        params.ForEach(func(k lua.LValue, v lua.LValue) {
+            args = append(args, ConvertLuaTypesToGolang(v))
+        })
+    }
+
+    if conn.log {
+        conn.logger.Info("DB QueryRow",
+            slog.String("query", query),
+            slog.Any("params", args))
+    }
+
+    mtx := getDBMutex(conn.dbPath)
+    mtx.RLock()
+    defer mtx.RUnlock()
+
+    db, err := sql.Open("sqlite", conn.dbPath+"?_busy_timeout=5000&_journal_mode=WAL&_sync=NORMAL&_cache_size=-10000")
+    if err != nil {
+        L.Push(lua.LNil)
+        L.Push(lua.LString(err.Error()))
+        return 2
+    }
+    defer db.Close()
+
+    row := db.QueryRow(query, args...)
+
+	columns := []string{}
+	stmt, err := db.Prepare(query)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("prepare failed: %v", err)))
+		return 2
+	}
+	defer stmt.Close()
+	rows, err := stmt.Query(args...)
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("query failed: %v", err)))
+		return 2
+	}
+	defer rows.Close()
+	cols, err := rows.Columns()
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(fmt.Sprintf("get columns failed: %v", err)))
+		return 2
+	}
+	for _, c := range cols {
+		columns = append(columns, c)
+	}
+
+    colCount := len(columns)
+    values := make([]any, colCount)
+    valuePtrs := make([]any, colCount)
+    for i := range columns {
+        valuePtrs[i] = &values[i]
+    }
+
+    err = row.Scan(valuePtrs...)
+    if err != nil {
+        if err == sql.ErrNoRows {
+            L.Push(lua.LNil)
+            return 1
+        }
+        L.Push(lua.LNil)
+        L.Push(lua.LString(fmt.Sprintf("scan failed: %v", err)))
+        return 2
+    }
+
+    rowTable := L.NewTable()
+    for i, col := range columns {
+        val := values[i]
+        if val == nil {
+            L.SetField(rowTable, col, lua.LNil)
+        } else {
+            L.SetField(rowTable, col, ConvertGolangTypesToLua(L, val))
+        }
+    }
+
+    L.Push(rowTable)
+    return 1
+}
+
+func dbQuery(L *lua.LState) int {
+	ud := L.CheckUserData(1)
+	conn, ok := ud.Value.(*DBConnection)
+	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
+}
--- a/src/internal/server/sv1/handle.go
+++ b/src/internal/server/sv1/handle.go
@@ -0,0 +1,39 @@
+package sv1
+
+import (
+	"context"
+	"log/slog"
+	"net/http"
+
+	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+)
+
+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, 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, 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, nil, req.ID)
+		}
+	}
+	switch req.Params.(type) {
+	case map[string]any, []any, nil:
+		return h.handleLUA(sid, r, req, method)
+	default:
+		// JSON-RPC 2.0 Specification:
+		// https://www.jsonrpc.org/specification#parameter_structures
+		//
+		// "params" MUST be either an *array* or an *object* if included.
+		// Any other type (e.g., a number, string, or boolean) is INVALID.
+		h.x.SLog.Info("invalid request received", slog.String("issue", rpc.ErrInvalidParamsS))
+		return rpc.NewError(rpc.ErrInvalidParams, rpc.ErrInvalidParamsS, nil, req.ID)
+	}
+}
--- a/src/internal/server/sv1/jwt.go
+++ b/src/internal/server/sv1/jwt.go
@@ -0,0 +1,86 @@
+package sv1
+
+import (
+	"log/slog"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	lua "github.com/yuin/gopher-lua"
+)
+
+func loadJWTMod(llog *slog.Logger, sid string) func(*lua.LState) int {
+	return func(L *lua.LState) int {
+		llog.Debug("import module jwt")
+		jwtMod := L.NewTable()
+
+		L.SetField(jwtMod, "encode", L.NewFunction(jwtEncode))
+		L.SetField(jwtMod, "decode", L.NewFunction(jwtDecode))
+
+		L.SetField(jwtMod, "__seed", lua.LString(sid))
+		L.Push(jwtMod)
+		return 1
+	}
+}
+
+func jwtEncode(L *lua.LState) int {
+	payloadTbl := L.CheckTable(1)
+	secret := L.GetField(payloadTbl, "secret").String()
+	payload := L.GetField(payloadTbl, "payload").(*lua.LTable)
+	expiresIn := L.GetField(payloadTbl, "expires_in")
+	expDuration := time.Hour
+
+	if expiresIn.Type() == lua.LTNumber {
+		floatVal := ConvertLuaTypesToGolang(expiresIn).(float64)
+		expDuration = time.Duration(floatVal) * time.Second
+	}
+
+	claims := jwt.MapClaims{}
+	payload.ForEach(func(key, value lua.LValue) {
+		claims[key.String()] = ConvertLuaTypesToGolang(value)
+	})
+	claims["iat"] = time.Now().Unix()
+	claims["exp"] = time.Now().Add(expDuration).Unix()
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	signedToken, err := token.SignedString([]byte(secret))
+	if err != nil {
+		L.Push(lua.LNil)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+
+	L.Push(lua.LString(signedToken))
+	return 1
+}
+
+func jwtDecode(L *lua.LState) int {
+	tokenString := L.CheckString(1)
+	optsTbl := L.OptTable(2, L.NewTable())
+	secret := L.GetField(optsTbl, "secret").String()
+
+	token, err := jwt.Parse(tokenString, func(t *jwt.Token) (any, error) {
+		return []byte(secret), nil
+	})
+
+	if err != nil || !token.Valid {
+		L.Push(lua.LString("Invalid token: " + err.Error()))
+		L.Push(lua.LNil)
+		return 2
+	}
+
+	claims, ok := token.Claims.(jwt.MapClaims)
+	if !ok {
+		L.Push(lua.LString("Invalid claims"))
+		L.Push(lua.LNil)
+		return 2
+	}
+
+	luaTable := L.NewTable()
+	for k, v := range claims {
+		luaTable.RawSetString(k, ConvertGolangTypesToLua(L, v))
+	}
+
+	L.Push(lua.LNil)
+	L.Push(luaTable)
+	return 2
+}
--- a/src/internal/server/sv1/lua_handler.go
+++ b/src/internal/server/sv1/lua_handler.go
@@ -0,0 +1,636 @@
+package sv1
+
+// TODO: make a lua state pool using sync.Pool
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"log/slog"
+	"math/rand/v2"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"golang.org/x/crypto/bcrypt"
+
+	"github.com/akyaiy/GoSally-mvp/internal/colors"
+	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+	lua "github.com/yuin/gopher-lua"
+	_ "modernc.org/sqlite"
+)
+
+func addInitiatorHeaders(sid string, req *http.Request, headers http.Header) {
+	clientIP := req.RemoteAddr
+	if forwardedFor := req.Header.Get("X-Forwarded-For"); forwardedFor != "" {
+		clientIP = forwardedFor
+	}
+	headers.Set("X-Initiator-IP", clientIP)
+	headers.Set("X-Session-UUID", sid)
+	headers.Set("X-Initiator-Host", req.Host)
+	headers.Set("X-Initiator-User-Agent", req.UserAgent())
+	headers.Set("X-Initiator-Referer", req.Referer())
+}
+
+// A small reminder: this code is only at the MVP stage,
+// and some parts of the code may cause shock from the
+// incompetence of the developer. But, in the end,
+// this code is just an idea. If there is a desire to
+// contribute to the development of the code,
+// I will be only glad.
+// TODO: make this huge function more harmonious by dividing responsibilities
+func (h *HandlerV1) handleLUA(sid string, r *http.Request, req *rpc.RPCRequest, path string) *rpc.RPCResponse {
+	var __exit = -1
+
+	llog := h.x.SLog.With(slog.String("session-id", sid))
+	llog.Debug("handling LUA")
+	L := lua.NewState()
+	defer L.Close()
+
+	osMod := L.GetGlobal("os").(*lua.LTable)
+	L.SetField(osMod, "exit", lua.LNil)
+
+	ioMod := L.GetGlobal("io").(*lua.LTable)
+	for _, k := range []string{"write", "output", "flush", "read", "input"} {
+		ioMod.RawSetString(k, lua.LNil)
+	}
+	L.Env.RawSetString("print", lua.LNil)
+
+	for _, name := range []string{"stdout", "stderr", "stdin"} {
+		stream := ioMod.RawGetString(name)
+		if t, ok := stream.(*lua.LUserData); ok {
+			t.Metatable = lua.LNil
+		}
+	}
+
+	seed := rand.Int()
+
+	loadSessionMod := func(L *lua.LState) int {
+		llog.Debug("import module session", slog.String("script", path))
+		sessionMod := L.NewTable()
+		inTable := L.NewTable()
+		paramsTable := L.NewTable()
+		headersTable := L.NewTable()
+
+		fetchedHeadersTable := L.NewTable()
+		for k, v := range r.Header {
+			L.SetField(fetchedHeadersTable, k, ConvertGolangTypesToLua(L, v))
+		}
+
+		headersGetter := L.NewFunction(func(L *lua.LState) int {
+			path := L.OptString(1, "")
+			def := L.Get(2)
+
+			get := func(path string) lua.LValue {
+				if path == "" {
+					return fetchedHeadersTable
+				}
+				fetched := r.Header.Get(path)
+				if fetched == "" {
+					return lua.LNil
+				}
+				return lua.LString(fetched)
+			}
+			val := get(path)
+			if val == lua.LNil && def != lua.LNil {
+				L.Push(def)
+			} else {
+				L.Push(val)
+			}
+			return 1
+		})
+
+		L.SetField(headersTable, "__fetched", fetchedHeadersTable)
+
+		L.SetField(headersTable, "get", headersGetter)
+		L.SetField(inTable, "headers", headersTable)
+
+		fetchedParamsTable := L.NewTable()
+		switch params := req.Params.(type) {
+		case map[string]any:
+			for k, v := range params {
+				L.SetField(fetchedParamsTable, k, ConvertGolangTypesToLua(L, v))
+			}
+		case []any:
+			for i, v := range params {
+				fetchedParamsTable.RawSetInt(i+1, ConvertGolangTypesToLua(L, v))
+			}
+		}
+
+		paramsGetter := L.NewFunction(func(L *lua.LState) int {
+			path := L.OptString(1, "")
+			def := L.Get(2)
+
+			get := func(tbl *lua.LTable, path string) lua.LValue {
+				if path == "" {
+					return tbl
+				}
+				current := tbl
+				parts := strings.Split(path, ".")
+				size := len(parts)
+				for index, key := range parts {
+					val := current.RawGetString(key)
+					if tblVal, ok := val.(*lua.LTable); ok {
+						current = tblVal
+					} else {
+						if index == size-1 {
+							return val
+						}
+						return lua.LNil
+					}
+				}
+				return current
+			}
+
+			paramsTbl := L.GetField(paramsTable, "__fetched") //
+			val := get(paramsTbl.(*lua.LTable), path)         //
+			if val == lua.LNil && def != lua.LNil {
+				L.Push(def)
+			} else {
+				L.Push(val)
+			}
+			return 1
+		})
+		L.SetField(paramsTable, "__fetched", fetchedParamsTable)
+
+		L.SetField(paramsTable, "get", paramsGetter)
+		L.SetField(inTable, "params", paramsTable)
+
+		outTable := L.NewTable()
+		scriptDataTable := L.NewTable()
+		L.SetField(outTable, "__script_data", scriptDataTable)
+
+		L.SetField(inTable, "address", lua.LString(r.RemoteAddr))
+
+		L.SetField(sessionMod, "throw_error", L.NewFunction(func(L *lua.LState) int {
+			arg := L.Get(1)
+			var msg string
+			switch arg.Type() {
+			case lua.LTString:
+				msg = arg.String()
+			case lua.LTNumber:
+				msg = strconv.FormatFloat(float64(arg.(lua.LNumber)), 'f', -1, 64)
+			default:
+				L.ArgError(1, "expected string or number")
+				return 0
+			}
+
+			L.RaiseError("%s", msg)
+			return 0
+		}))
+
+		resTable := L.NewTable()
+		L.SetField(scriptDataTable, "result", resTable)
+		L.SetField(outTable, "send", L.NewFunction(func(L *lua.LState) int {
+			res := L.Get(1)
+
+			resFTable := scriptDataTable.RawGetString("result")
+			if resPTable, ok := res.(*lua.LTable); ok {
+				resPTable.ForEach(func(key, value lua.LValue) {
+					L.SetField(resFTable, key.String(), value)
+				})
+			} else {
+				L.SetField(scriptDataTable, "result", res)
+			}
+
+			__exit = 0
+			L.RaiseError("__successfull")
+			return 0
+		}))
+
+		L.SetField(outTable, "set", L.NewFunction(func(L *lua.LState) int {
+			res := L.Get(1)
+			if res == lua.LNil {
+				return 0
+			}
+
+			resFTable := scriptDataTable.RawGetString("result")
+			if resPTable, ok := res.(*lua.LTable); ok {
+				resPTable.ForEach(func(key, value lua.LValue) {
+					L.SetField(resFTable, key.String(), value)
+				})
+			} else {
+				L.SetField(scriptDataTable, "result", res)
+			}
+			return 0
+		}))
+
+		errTable := L.NewTable()
+		L.SetField(scriptDataTable, "error", errTable)
+		L.SetField(outTable, "send_error", L.NewFunction(func(L *lua.LState) int {
+			var params [3]lua.LValue
+			for i := range 3 {
+				params[i] = L.Get(i + 1)
+			}
+			if errTable, ok := scriptDataTable.RawGetString("error").(*lua.LTable); ok {
+				for _, v := range params {
+					switch v.Type() {
+					case lua.LTNumber:
+						if n, ok := v.(lua.LNumber); ok {
+							L.SetField(errTable, "code", n)
+						}
+					case lua.LTString:
+						if s, ok := v.(lua.LString); ok {
+							L.SetField(errTable, "message", s)
+						}
+					case lua.LTTable:
+						if tbl, ok := v.(*lua.LTable); ok {
+							L.SetField(errTable, "data", tbl)
+						}
+					}
+				}
+			}
+
+			__exit = 1
+			L.RaiseError("__unsuccessfull")
+			return 0
+		}))
+
+		L.SetField(outTable, "set_error", L.NewFunction(func(L *lua.LState) int {
+			var params [3]lua.LValue
+			for i := range 3 {
+				params[i] = L.Get(i + 1)
+			}
+			if errTable, ok := scriptDataTable.RawGetString("error").(*lua.LTable); ok {
+				for _, v := range params {
+					switch v.Type() {
+					case lua.LTNumber:
+						if n, ok := v.(lua.LNumber); ok {
+							L.SetField(errTable, "code", n)
+						}
+					case lua.LTString:
+						if s, ok := v.(lua.LString); ok {
+							L.SetField(errTable, "message", s)
+						}
+					case lua.LTTable:
+						if tbl, ok := v.(*lua.LTable); ok {
+							L.SetField(errTable, "data", tbl)
+						}
+					}
+				}
+			}
+			return 0
+		}))
+
+		L.SetField(sessionMod, "request", inTable)
+		L.SetField(sessionMod, "response", outTable)
+
+		L.SetField(sessionMod, "id", lua.LString(sid))
+
+		L.SetField(sessionMod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(sessionMod)
+		return 1
+	}
+
+	loadLogMod := func(L *lua.LState) int {
+		llog.Debug("import module log", slog.String("script", path))
+		logMod := L.NewTable()
+
+		logFuncs := map[string]func(string, ...any){
+			"info":  llog.Info,
+			"debug": llog.Debug,
+			"error": llog.Error,
+			"warn":  llog.Warn,
+		}
+
+		for name, logFunc := range logFuncs {
+			fun := logFunc
+			L.SetField(logMod, name, L.NewFunction(func(L *lua.LState) int {
+				msg := L.Get(1)
+				converted := ConvertLuaTypesToGolang(msg)
+				fun(fmt.Sprintf("the script says: %s", converted), slog.String("script", path))
+				return 0
+			}))
+		}
+
+		for _, fn := range []struct {
+			field string
+			pfunc func(string, ...any)
+			color func() string
+		}{
+			{"event", h.x.Log.Printf, nil},
+			{"event_error", h.x.Log.Printf, colors.PrintError},
+			{"event_warn", h.x.Log.Printf, colors.PrintWarn},
+		} {
+			L.SetField(logMod, fn.field, L.NewFunction(func(L *lua.LState) int {
+				msg := L.Get(1)
+				converted := ConvertLuaTypesToGolang(msg)
+				if fn.color != nil {
+					h.x.Log.Printf("%s: %s: %s", fn.color(), path, converted)
+				} else {
+					h.x.Log.Printf("%s: %s", path, converted)
+				}
+				return 0
+			}))
+		}
+
+		L.SetField(logMod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(logMod)
+		return 1
+	}
+
+	loadNetMod := func(L *lua.LState) int {
+		llog.Debug("import module net", slog.String("script", path))
+		netMod := L.NewTable()
+		netModhttp := L.NewTable()
+
+		L.SetField(netModhttp, "get_request", L.NewFunction(func(L *lua.LState) int {
+			logRequest := L.ToBool(1)
+			url := L.ToString(2)
+
+			req, err := http.NewRequest("GET", url, nil)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+
+			addInitiatorHeaders(sid, r, req.Header)
+
+			client := &http.Client{}
+			resp, err := client.Do(req)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+			defer resp.Body.Close()
+
+			body, err := io.ReadAll(resp.Body)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+
+			if logRequest {
+				llog.Info("HTTP GET request",
+					slog.String("script", path),
+					slog.String("url", url),
+					slog.Int("status", resp.StatusCode),
+					slog.String("status_text", resp.Status),
+					slog.String("initiator_ip", req.Header.Get("X-Initiator-IP")),
+				)
+			}
+
+			result := L.NewTable()
+			L.SetField(result, "status", lua.LNumber(resp.StatusCode))
+			L.SetField(result, "status_text", lua.LString(resp.Status))
+			L.SetField(result, "body", lua.LString(body))
+			L.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
+
+			headers := L.NewTable()
+			for k, v := range resp.Header {
+				L.SetField(headers, k, ConvertGolangTypesToLua(L, v))
+			}
+			L.SetField(result, "headers", headers)
+
+			L.Push(result)
+			return 1
+		}))
+
+		L.SetField(netModhttp, "post_request", L.NewFunction(func(L *lua.LState) int {
+			logRequest := L.ToBool(1)
+			url := L.ToString(2)
+			contentType := L.ToString(3)
+			payload := L.ToString(4)
+
+			body := strings.NewReader(payload)
+
+			req, err := http.NewRequest("POST", url, body)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+
+			req.Header.Set("Content-Type", contentType)
+
+			addInitiatorHeaders(sid, r, req.Header)
+
+			client := &http.Client{}
+			resp, err := client.Do(req)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+			defer resp.Body.Close()
+
+			respBody, err := io.ReadAll(resp.Body)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString(err.Error()))
+				return 2
+			}
+
+			if logRequest {
+				llog.Info("HTTP POST request",
+					slog.String("script", path),
+					slog.String("url", url),
+					slog.String("content_type", contentType),
+					slog.Int("status", resp.StatusCode),
+					slog.String("status_text", resp.Status),
+					slog.String("initiator_ip", req.Header.Get("X-Initiator-IP")),
+				)
+			}
+
+			result := L.NewTable()
+			L.SetField(result, "status", lua.LNumber(resp.StatusCode))
+			L.SetField(result, "status_text", lua.LString(resp.Status))
+			L.SetField(result, "body", lua.LString(respBody))
+			L.SetField(result, "content_length", lua.LNumber(resp.ContentLength))
+
+			headers := L.NewTable()
+			for k, v := range resp.Header {
+				L.SetField(headers, k, ConvertGolangTypesToLua(L, v))
+			}
+			L.SetField(result, "headers", headers)
+
+			L.Push(result)
+			return 1
+		}))
+
+		L.SetField(netMod, "http", netModhttp)
+
+		L.SetField(netMod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(netMod)
+		return 1
+	}
+
+	loadCryptbcryptMod := func(L *lua.LState) int {
+		llog.Debug("import module crypt.bcrypt", slog.String("script", path))
+		bcryptMod := L.NewTable()
+
+		L.SetField(bcryptMod, "MinCost", lua.LNumber(bcrypt.MinCost))
+		L.SetField(bcryptMod, "MaxCost", lua.LNumber(bcrypt.MaxCost))
+		L.SetField(bcryptMod, "DefaultCost", lua.LNumber(bcrypt.DefaultCost))
+
+		L.SetField(bcryptMod, "generate", L.NewFunction(func(l *lua.LState) int {
+			password := ConvertLuaTypesToGolang(L.Get(1))
+			passwordStr, ok := password.(string)
+			if !ok {
+				L.Push(lua.LNil)
+				L.Push(lua.LString("error: password must be a string"))
+				return 2
+			}
+
+			cost := ConvertLuaTypesToGolang(L.Get(2))
+			costInt := bcrypt.DefaultCost
+			switch v := cost.(type) {
+			case int:
+				costInt = v
+			case float64:
+				costInt = int(v)
+			case nil:
+				// ok, use DefaultCost
+			default:
+				L.Push(lua.LNil)
+				L.Push(lua.LString("error: cost must be an integer"))
+				return 2
+			}
+
+			hashBytes, err := bcrypt.GenerateFromPassword([]byte(passwordStr), costInt)
+			if err != nil {
+				L.Push(lua.LNil)
+				L.Push(lua.LString("error: " + err.Error()))
+				return 2
+			}
+
+			L.Push(lua.LString(string(hashBytes)))
+			L.Push(lua.LNil)
+			return 2
+		}))
+
+		L.SetField(bcryptMod, "compare", L.NewFunction(func(l *lua.LState) int {
+			hash := ConvertLuaTypesToGolang(L.Get(1))
+			hashStr, ok := hash.(string)
+			if !ok {
+				L.Push(lua.LString("error: hash must be a string"))
+				return 1
+			}
+			password := ConvertLuaTypesToGolang(L.Get(2))
+			passwordStr, ok := password.(string)
+			if !ok {
+				L.Push(lua.LString("error: password must be a string"))
+				return 1
+			}
+
+			err := bcrypt.CompareHashAndPassword([]byte(hashStr), []byte(passwordStr))
+			if err != nil {
+				L.Push(lua.LFalse)
+				return 1
+			}
+			L.Push(lua.LTrue)
+			return 1
+		}))
+
+		L.SetField(bcryptMod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(bcryptMod)
+		return 1
+	}
+
+	loadCryptbsha256Mod := func(L *lua.LState) int {
+		llog.Debug("import module crypt.sha256", slog.String("script", path))
+		sha265mod := L.NewTable()
+
+		L.SetField(sha265mod, "hash", L.NewFunction(func(l *lua.LState) int {
+			data := ConvertLuaTypesToGolang(L.Get(1))
+			var dataStr = fmt.Sprint(data)
+
+			hash := sha256.Sum256([]byte(dataStr))
+
+			L.Push(lua.LString(hex.EncodeToString(hash[:])))
+			L.Push(lua.LNil)
+			return 2
+		}))
+
+		L.SetField(sha265mod, "__seed", lua.LString(fmt.Sprint(seed)))
+		L.Push(sha265mod)
+		return 1
+	}
+
+	L.PreloadModule("internal.session", loadSessionMod)
+	L.PreloadModule("internal.log", loadLogMod)
+	L.PreloadModule("internal.net", loadNetMod)
+	L.PreloadModule("internal.database.sqlite", loadDBMod(llog, fmt.Sprint(seed)))
+	L.PreloadModule("internal.crypt.bcrypt", loadCryptbcryptMod)
+	L.PreloadModule("internal.crypt.sha256", loadCryptbsha256Mod)
+	L.PreloadModule("internal.crypt.jwt", loadJWTMod(llog, fmt.Sprint(seed)))
+
+	llog.Debug("preparing environment")
+	prep := filepath.Join(*h.x.Config.Conf.Node.ComDir, "_prepare.lua")
+	if _, err := os.Stat(prep); err == nil {
+		if err := L.DoFile(prep); err != nil {
+			llog.Error("script error", slog.String("script", path), slog.String("error", err.Error()))
+			return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+		}
+	}
+	llog.Debug("executing script", slog.String("script", path))
+	err := L.DoFile(path)
+	if err != nil && __exit != 0 && __exit != 1 {
+		llog.Error("script error", slog.String("script", path), slog.String("error", err.Error()))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	pkg := L.GetGlobal("package")
+	pkgTbl, ok := pkg.(*lua.LTable)
+	if !ok {
+		llog.Error("script error", slog.String("script", path), slog.String("error", "package not found"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	loaded := pkgTbl.RawGetString("loaded")
+	loadedTbl, ok := loaded.(*lua.LTable)
+	if !ok {
+		llog.Error("script error", slog.String("script", path), slog.String("error", "package.loaded not found"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	sessionVal := loadedTbl.RawGetString("internal.session")
+	sessionTbl, ok := sessionVal.(*lua.LTable)
+	if !ok {
+		return rpc.NewResponse(nil, req.ID)
+	}
+
+	tag := sessionTbl.RawGetString("__seed")
+	if tag.Type() != lua.LTString || tag.String() != fmt.Sprint(seed) {
+		llog.Debug("stock session module is not imported: wrong seed", slog.String("script", path))
+		return rpc.NewResponse(nil, req.ID)
+	}
+
+	outVal := sessionTbl.RawGetString("response")
+	outTbl, ok := outVal.(*lua.LTable)
+	if !ok {
+		llog.Error("script error", slog.String("script", path), slog.String("error", "response is not a table"))
+		return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+	}
+
+	if scriptDataTable, ok := outTbl.RawGetString("__script_data").(*lua.LTable); ok {
+		switch __exit {
+		case 1:
+			if errTbl, ok := scriptDataTable.RawGetString("error").(*lua.LTable); ok {
+				llog.Debug("catch error table", slog.String("script", path))
+				code := rpc.ErrInternalError
+				message := rpc.ErrInternalErrorS
+				if c := errTbl.RawGetString("code"); c.Type() == lua.LTNumber {
+					code = int(c.(lua.LNumber))
+				}
+				if msg := errTbl.RawGetString("message"); msg.Type() == lua.LTString {
+					message = msg.String()
+				}
+				data := ConvertLuaTypesToGolang(errTbl.RawGetString("data"))
+				llog.Error("the script terminated with an error", slog.Int("code", code), slog.String("message", message), slog.Any("data", data))
+				return rpc.NewError(code, message, data, req.ID)
+			}
+			return rpc.NewError(rpc.ErrInternalError, rpc.ErrInternalErrorS, nil, req.ID)
+		case 0:
+			resVal := ConvertLuaTypesToGolang(scriptDataTable.RawGetString("result"))
+			return rpc.NewResponse(resVal, req.ID)
+		}
+	}
+	return rpc.NewResponse(nil, req.ID)
+}
--- a/src/internal/server/sv1/lua_types.go
+++ b/src/internal/server/sv1/lua_types.go
@@ -0,0 +1,126 @@
+package sv1
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+func ConvertLuaTypesToGolang(value lua.LValue) any {
+	switch value.Type() {
+	case lua.LTString:
+		return value.String()
+	case lua.LTNumber:
+		return float64(value.(lua.LNumber))
+	case lua.LTBool:
+		return bool(value.(lua.LBool))
+	case lua.LTTable:
+		tbl := value.(*lua.LTable)
+
+		maxIdx := 0
+		isArray := true
+
+		var isNumeric = false
+		tbl.ForEach(func(key, _ lua.LValue) {
+			var numKey lua.LValue
+			var ok bool
+			switch key.Type() {
+			case lua.LTString:
+				numKey, ok = key.(lua.LString)
+				if !ok {
+					isArray = false
+					return
+				}
+			case lua.LTNumber:
+				numKey, ok = key.(lua.LNumber)
+				if !ok {
+					isArray = false
+					return
+				}
+				isNumeric = true
+			}
+
+			num, err := strconv.Atoi(numKey.String())
+			if err != nil {
+				isArray = false
+				return
+			}
+			if num < 1 {
+				isArray = false
+				return
+			}
+			if num > maxIdx {
+				maxIdx = num
+			}
+		})
+
+		if isArray {
+			arr := make([]any, maxIdx)
+			if isNumeric {
+				for i := 1; i <= maxIdx; i++ {
+					arr[i-1] = ConvertLuaTypesToGolang(tbl.RawGetInt(i))
+				}
+			} else {
+				for i := 1; i <= maxIdx; i++ {
+					arr[i-1] = ConvertLuaTypesToGolang(tbl.RawGetString(strconv.Itoa(i)))
+				}
+			}
+			return arr
+		}
+		result := make(map[string]any)
+		tbl.ForEach(func(key, val lua.LValue) {
+			result[key.String()] = ConvertLuaTypesToGolang(val)
+		})
+		return result
+
+	case lua.LTNil:
+		return nil
+	default:
+		return value.String()
+	}
+}
+
+func ConvertGolangTypesToLua(L *lua.LState, val any) lua.LValue {
+	if val == nil {
+		return lua.LNil
+	}
+
+	rv := reflect.ValueOf(val)
+	rt := rv.Type()
+
+	switch rt.Kind() {
+	case reflect.String:
+		return lua.LString(rv.String())
+	case reflect.Bool:
+		return lua.LBool(rv.Bool())
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return lua.LNumber(rv.Int())
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		return lua.LNumber(rv.Uint())
+	case reflect.Float32, reflect.Float64:
+		return lua.LNumber(rv.Float())
+
+	case reflect.Slice, reflect.Array:
+		tbl := L.NewTable()
+		for i := 0; i < rv.Len(); i++ {
+			tbl.RawSetInt(i+1, ConvertGolangTypesToLua(L, rv.Index(i).Interface()))
+		}
+		return tbl
+
+	case reflect.Map:
+		if rt.Key().Kind() == reflect.String {
+			tbl := L.NewTable()
+			for _, key := range rv.MapKeys() {
+				val := rv.MapIndex(key)
+				tbl.RawSetString(key.String(), ConvertGolangTypesToLua(L, val.Interface()))
+			}
+			return tbl
+		}
+
+	default:
+		return lua.LString(fmt.Sprintf("%v", val))
+	}
+	return lua.LString(fmt.Sprintf("%v", val))
+}
--- a/src/internal/server/sv1/path.go
+++ b/src/internal/server/sv1/path.go
@@ -0,0 +1,28 @@
+package sv1
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+)
+
+var RPCMethodSeparator = "."
+
+func (h *HandlerV1) resolveMethodPath(method string) (string, error) {
+	if !h.allowedCmd.MatchString(method) {
+		return "", errors.New(rpc.ErrInvalidMethodFormatS)
+	}
+
+	parts := strings.Split(method, RPCMethodSeparator)
+	relPath := filepath.Join(parts...) + ".lua"
+	fullPath := filepath.Join(*h.x.Config.Conf.Node.ComDir, relPath)
+
+	if _, err := os.Stat(fullPath); os.IsNotExist(err) {
+		return "", errors.New(rpc.ErrMethodNotFoundS)
+	}
+
+	return fullPath, nil
+}
--- a/src/internal/server/sv1/server.go
+++ b/src/internal/server/sv1/server.go
@@ -0,0 +1,47 @@
+// Package sv1 provides the implementation of the Server V1 API handler.
+// It includes utilities for handling API requests, extracting descriptions, and managing UUIDs.
+package sv1
+
+import (
+	"regexp"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/app"
+)
+
+// HandlerV1InitStruct structure is only for initialization
+type HandlerV1InitStruct struct {
+	Ver        string
+	CS         *corestate.CoreState
+	X          *app.AppX
+	AllowedCmd *regexp.Regexp
+}
+
+// HandlerV1 implements the ServerV1UtilsContract and serves as the main handler for API requests.
+type HandlerV1 struct {
+	cs *corestate.CoreState
+	x  *app.AppX
+
+	// allowedCmd and listAllowedCmd are regular expressions used to validate command names.
+	allowedCmd *regexp.Regexp
+
+	ver string
+}
+
+// InitV1Server initializes a new HandlerV1 with the provided configuration and returns it.
+// Should be carefull with giving to this function invalid parameters,
+// because there is no validation of parameters in this function.
+func InitV1Server(o *HandlerV1InitStruct) *HandlerV1 {
+	return &HandlerV1{
+		cs:         o.CS,
+		x:          o.X,
+		allowedCmd: o.AllowedCmd,
+		ver:        o.Ver,
+	}
+}
+
+// GetVersion returns the API version of the HandlerV1, which is set during initialization.
+// This version is used to identify the API version in the request routing.
+func (h *HandlerV1) GetVersion() string {
+	return h.ver
+}
--- a/src/main.go
+++ b/src/main.go
@@ -0,0 +1,11 @@
+// Package main used only for calling cmd.Execute()
+package main
+
+import (
+	"github.com/akyaiy/GoSally-mvp/cmd"
+	_ "modernc.org/sqlite"
+)
+
+func main() {
+	cmd.Execute()
+}