Project structure refactor:

- Change package name general_server to gateway - Changing the structure of directories and packages - Adding vendor to the project
2026-03-02 19:52:26 +00:00 · 2025-07-28 20:16:40 +03:00
parent 19b699d92b
commit ec94df5f4a
786 changed files with 357010 additions and 357 deletions
--- a/internal/core/corestate/corestate.go
+++ b/internal/core/corestate/corestate.go
@@ -0,0 +1,22 @@
+package corestate
+
+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/internal/core/corestate/node_uuid.go
+++ b/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/internal/core/corestate/types.go
+++ b/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/internal/core/run_manager/run_file_manager.go
+++ b/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/internal/core/run_manager/run_manager.go
+++ b/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/internal/core/update/update.go
+++ b/internal/core/update/update.go
@@ -0,0 +1,335 @@
+package update
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"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/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 {
+	log    *log.Logger
+	config *config.Conf
+	env    *config.Env
+
+	ctx    context.Context
+	cancel context.CancelFunc
+}
+
+func NewUpdater(ctx context.Context, log *log.Logger, cfg *config.Conf, env *config.Env) *Updater {
+	return &Updater{
+		log:    log,
+		config: cfg,
+		env:    env,
+		ctx:    ctx,
+	}
+}
+
+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.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.config.Updates.RepositoryURL
+	if repoURL == "" {
+		u.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.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.log.Printf("Failed to fetch latest version: %s", err.Error())
+		return "", "", err
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		u.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.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.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.config.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.config.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.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.log.Printf("Launching new version: path is %s", targetPath)
+	// cmd := exec.Command(targetPath, os.Args[1:]...)
+	// cmd.Env = os.Environ()
+	// cmd.Stdout = os.Stdout
+	// cmd.Stderr = os.Stderr
+	// cmd.Stdin = os.Stdin
+	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)
+	//u.cancel()
+
+	// TODO: fix this crap and find a better way to update without errors
+	// for {
+	// 	_, err := run_manager.Get("run.lock")
+	// 	if err != nil {
+	// 		break
+	// 	}
+	// }
+
+	// return cmd.Start()
+}
+
+func (u *Updater) Shutdownfunc(f context.CancelFunc) {
+	u.cancel = f
+}
--- a/internal/core/update/update_test.go
+++ b/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/internal/core/utils/http_errors.go
+++ b/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/internal/core/utils/internal_lua.go
+++ b/internal/core/utils/internal_lua.go
@@ -0,0 +1,78 @@
+package utils
+
+import (
+	"fmt"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+func ConvertLuaTypesToGolang(value lua.LValue) any {
+	switch value.Type() {
+	case lua.LTString:
+		return value.String()
+	case lua.LTNumber:
+		return float64(value.(lua.LNumber))
+	case lua.LTBool:
+		return bool(value.(lua.LBool))
+	case lua.LTTable:
+		tbl := value.(*lua.LTable)
+
+		// Попробуем как массив
+		var arr []any
+		isArray := true
+		tbl.ForEach(func(key, val lua.LValue) {
+			if key.Type() != lua.LTNumber {
+				isArray = false
+			}
+			arr = append(arr, ConvertLuaTypesToGolang(val))
+		})
+
+		if isArray {
+			return arr
+		}
+
+		result := make(map[string]any)
+		tbl.ForEach(func(key, val lua.LValue) {
+			result[key.String()] = ConvertLuaTypesToGolang(val)
+		})
+		return result
+
+	case lua.LTNil:
+		return nil
+	default:
+		return value.String()
+	}
+}
+
+func ConvertGolangTypesToLua(L *lua.LState, val any) lua.LValue {
+	switch v := val.(type) {
+	case string:
+		return lua.LString(v)
+	case bool:
+		return lua.LBool(v)
+	case int:
+		return lua.LNumber(float64(v))
+	case int64:
+		return lua.LNumber(float64(v))
+	case float32:
+		return lua.LNumber(float64(v))
+	case float64:
+		return lua.LNumber(v)
+	case []any:
+		tbl := L.NewTable()
+		for i, item := range v {
+			tbl.RawSetInt(i+1, ConvertGolangTypesToLua(L, item))
+		}
+		return tbl
+	case map[string]any:
+		tbl := L.NewTable()
+		for key, value := range v {
+			tbl.RawSetString(key, ConvertGolangTypesToLua(L, value))
+		}
+		return tbl
+	case nil:
+		return lua.LNil
+	default:
+		return lua.LString(fmt.Sprintf("%v", v))
+	}
+}
--- a/internal/core/utils/routines.go
+++ b/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/internal/core/utils/utils_test.go
+++ b/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/internal/core/utils/uuid.go
+++ b/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/internal/engine/app/app.go
+++ b/internal/engine/app/app.go
@@ -0,0 +1,64 @@
+package app
+
+import (
+	"context"
+	"log"
+	"log/slog"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/internal/core/update"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+)
+
+type AppContract interface {
+	InitialHooks(fn ...func(cs *corestate.CoreState, x *AppX))
+	Run(fn func(ctx context.Context, cs *corestate.CoreState, x *AppX) error)
+}
+
+type App struct {
+	initHooks []func(cs *corestate.CoreState, x *AppX)
+	runHook   func(ctx context.Context, cs *corestate.CoreState, x *AppX) error
+
+	Corestate *corestate.CoreState
+	AppX      *AppX
+}
+
+type AppX struct {
+	Config  *config.Compositor
+	Log     *log.Logger
+	SLog    *slog.Logger
+	Updated *update.Updater
+}
+
+func New() AppContract {
+	return &App{
+		AppX: &AppX{
+			Log: log.Default(),
+		},
+		Corestate: &corestate.CoreState{},
+	}
+}
+
+func (a *App) InitialHooks(fn ...func(cs *corestate.CoreState, x *AppX)) {
+	a.initHooks = append(a.initHooks, fn...)
+}
+
+func (a *App) Run(fn func(ctx context.Context, cs *corestate.CoreState, x *AppX) error) {
+	a.runHook = fn
+
+	for _, hook := range a.initHooks {
+		hook(a.Corestate, a.AppX)
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+	defer stop()
+
+	if a.runHook != nil {
+		if err := a.runHook(ctx, a.Corestate, a.AppX); err != nil {
+			log.Fatalf("fatal in Run: %v", err)
+		}
+	}
+}
--- a/internal/engine/config/compositor.go
+++ b/internal/engine/config/compositor.go
@@ -0,0 +1,182 @@
+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("mode", "dev")
+	v.SetDefault("com_dir", "./com/")
+	v.SetDefault("http_server.address", "0.0.0.0")
+	v.SetDefault("http_server.port", "8080")
+	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.level", "info")
+	v.SetDefault("log.out_path", "")
+
+	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/internal/engine/config/config.go
+++ b/internal/engine/config/config.go
@@ -0,0 +1,80 @@
+// 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 {
+	Mode            string     `mapstructure:"mode"`
+	ComDir          string     `mapstructure:"com_dir"`
+	HTTPServer      HTTPServer `mapstructure:"http_server"`
+	TLS             TLS        `mapstructure:"tls"`
+	Updates         Updates    `mapstructure:"updates"`
+	Log             Log        `mapstructure:"log"`
+	DisableWarnings []string   `mapstructure:"disable_warnings"`
+}
+
+type HTTPServer struct {
+	Address        string         `mapstructure:"address"`
+	Port           string         `mapstructure:"port"`
+	Timeout        time.Duration  `mapstructure:"timeout"`
+	IdleTimeout    time.Duration  `mapstructure:"idle_timeout"`
+	HTTPServer_Api HTTPServer_Api `mapstructure:"api"`
+}
+
+type HTTPServer_Api struct {
+	LatestVer string   `mapstructure:"latest-version"`
+	Layers    []string `mapstructure:"layers"`
+}
+
+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 {
+	Level   string `mapstructure:"level"`
+	OutPath string `mapstructure:"out_path"`
+}
+
+// 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/internal/engine/config/consts.go
+++ b/internal/engine/config/consts.go
@@ -0,0 +1,34 @@
+package config
+
+import "os"
+
+// 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/internal/engine/logs/color.go
+++ b/internal/engine/logs/color.go
@@ -0,0 +1,24 @@
+package logs
+
+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/internal/engine/logs/logger.go
+++ b/internal/engine/logs/logger.go
@@ -0,0 +1,87 @@
+// 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"
+	"regexp"
+	"strings"
+
+	"github.com/akyaiy/GoSally-mvp/internal/core/run_manager"
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"gopkg.in/natefinch/lumberjack.v2"
+)
+
+var GlobalLevel slog.Level
+
+type 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
+	}
+
+	if o.OutPath != "" {
+		repl := map[string]string{
+			"tmp": filepath.Clean(run_manager.RuntimeDir()),
+		}
+		re := regexp.MustCompile(`%(\w+)%`)
+		result := re.ReplaceAllStringFunc(o.OutPath, func(match string) string {
+			sub := re.FindStringSubmatch(match)
+			if len(sub) < 2 {
+				return match
+			}
+			key := sub[1]
+			if val, ok := repl[key]; ok {
+				return val
+			}
+			return match
+		})
+
+		if strings.Contains(o.OutPath, "%tmp%") {
+			relPath := strings.TrimPrefix(result, filepath.Clean(run_manager.RuntimeDir()))
+			if err := run_manager.SetDir(relPath); err != nil {
+				return nil, err
+			}
+		}
+
+		logFile := &lumberjack.Logger{
+			Filename:   filepath.Join(result, "event.log"),
+			MaxSize:    10,
+			MaxBackups: 5,
+			MaxAge:     28,
+			Compress:   true,
+		}
+		writer = logFile
+	}
+
+	log := slog.New(slog.NewJSONHandler(writer, &handlerOpts))
+	return log, nil
+}
--- a/internal/engine/logs/mock.go
+++ b/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/internal/server/gateway/general_types.go
+++ b/internal/server/gateway/general_types.go
@@ -0,0 +1,30 @@
+package gateway
+
+import (
+	"log/slog"
+	"net/http"
+
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+)
+
+// 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(w http.ResponseWriter, r *http.Request, req rpc.RPCRequest)
+}
+
+// GeneralServer implements the GeneralServerApiContract and serves as a router for different API versions.
+type GatewayServer struct {
+	w http.ResponseWriter
+	r *http.Request
+
+	// 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
+
+	log *slog.Logger
+	cfg *config.Conf
+}
--- a/internal/server/gateway/init.go
+++ b/internal/server/gateway/init.go
@@ -0,0 +1,44 @@
+package gateway
+
+import (
+	"errors"
+	"log/slog"
+
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+)
+
+// GeneralServerInit structure only for initialization general server.
+type GatewayServerInit struct {
+	Log    *slog.Logger
+	Config *config.Conf
+}
+
+// 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),
+		cfg:     o.Config,
+		log:     o.Log,
+	}
+
+	// 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/internal/server/gateway/route.go
+++ b/internal/server/gateway/route.go
@@ -0,0 +1,80 @@
+package gateway
+
+import (
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+
+	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+)
+
+func (gs *GatewayServer) Handle(w http.ResponseWriter, r *http.Request) {
+	var req rpc.RPCRequest
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		rpc.WriteRouterError(w, http.StatusBadRequest, &rpc.RPCError{
+			JSONRPC: rpc.JSONRPCVersion,
+			ID:      nil,
+			Error: map[string]any{
+				"code":    rpc.ErrInternalError,
+				"message": rpc.ErrInternalErrorS,
+			},
+		})
+		gs.log.Info("invalid request received", slog.String("issue", rpc.ErrInternalErrorS))
+		return
+	}
+
+	if err := json.Unmarshal(body, &req); err != nil {
+		rpc.WriteRouterError(w, http.StatusBadRequest, &rpc.RPCError{
+			JSONRPC: rpc.JSONRPCVersion,
+			ID:      nil,
+			Error: map[string]any{
+				"code":    rpc.ErrParseError,
+				"message": rpc.ErrParseErrorS,
+			},
+		})
+		gs.log.Info("invalid request received", slog.String("issue", rpc.ErrParseErrorS))
+		return
+	}
+
+	if req.JSONRPC != rpc.JSONRPCVersion {
+		rpc.WriteRouterError(w, http.StatusBadRequest, &rpc.RPCError{
+			JSONRPC: rpc.JSONRPCVersion,
+			ID:      req.ID,
+			Error: map[string]any{
+				"code":    rpc.ErrInvalidRequest,
+				"message": rpc.ErrInvalidRequestS,
+			},
+		})
+		gs.log.Info("invalid request received", slog.String("issue", rpc.ErrInvalidRequestS), slog.String("requested-version", req.JSONRPC))
+		return
+	}
+
+	gs.Route(w, r, req)
+}
+
+func (gs *GatewayServer) Route(w http.ResponseWriter, r *http.Request, req rpc.RPCRequest) {
+	server, ok := gs.servers[serversApiVer(req.Params.ContextVersion)]
+	if !ok {
+		rpc.WriteRouterError(w, http.StatusBadRequest, &rpc.RPCError{
+			JSONRPC: rpc.JSONRPCVersion,
+			ID:      req.ID,
+			Error: map[string]any{
+				"code":    rpc.ErrContextVersion,
+				"message": rpc.ErrContextVersionS,
+			},
+		})
+		gs.log.Info("invalid request received", slog.String("issue", rpc.ErrContextVersionS), slog.String("requested-version", req.Params.ContextVersion))
+		return
+	}
+
+	// checks if request is notification
+	if req.ID == nil {
+		rr := httptest.NewRecorder()
+		server.Handle(rr, r, req)
+		return
+	}
+	server.Handle(w, r, req)
+}
--- a/internal/server/rpc/definition.go
+++ b/internal/server/rpc/definition.go
@@ -0,0 +1,29 @@
+package rpc
+
+type RPCRequest struct {
+	JSONRPC string           `json:"jsonrpc"`
+	ID      any              `json:"id"`
+	Method  string           `json:"method"`
+	Params  RPCRequestParams `json:"params"`
+}
+
+type RPCRequestParams struct {
+	ContextVersion string         `json:"context-version"`
+	Method         map[string]any `json:"method-params"`
+}
+
+type RPCResponse struct {
+	JSONRPC string `json:"jsonrpc"`
+	ID      any    `json:"id"`
+	Result  any    `json:"result"`
+}
+
+type RPCError struct {
+	JSONRPC string `json:"jsonrpc"`
+	ID      any    `json:"id"`
+	Error   any    `json:"error"`
+}
+
+const (
+	JSONRPCVersion = "2.0"
+)
--- a/internal/server/rpc/errors.go
+++ b/internal/server/rpc/errors.go
@@ -0,0 +1,39 @@
+package rpc
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+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"
+)
+
+func WriteRouterError(w http.ResponseWriter, status int, e *RPCError) error {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+
+	data, err := json.Marshal(e)
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(data)
+	return err
+}
--- a/internal/server/sv1/handle.go
+++ b/internal/server/sv1/handle.go
@@ -0,0 +1,342 @@
+package sv1
+
+import (
+	"net/http"
+
+	"github.com/akyaiy/GoSally-mvp/internal/server/rpc"
+)
+
+func (h *HandlerV1) Handle(w http.ResponseWriter, r *http.Request, req rpc.RPCRequest) {
+	w.Write([]byte("Sigmas"))
+}
+
+// func (h *HandlerV1) Handle(w http.ResponseWriter, r *http.Request) {
+// 	var req PettiRequest
+// 	// server, ok := s.servers[serversApiVer(payload.PettiVer)]
+// 	// if !ok {
+// 	// 	WriteRouterError(w, &RouterError{
+// 	// 		Status:     "error",
+// 	// 		StatusCode: http.StatusBadRequest,
+// 	// 		Payload: map[string]any{
+// 	// 			"Message": InvalidProtovolVersion,
+// 	// 		},
+// 	// 	})
+// 	// 	s.log.Info("invalid request received", slog.String("issue", InvalidProtovolVersion), slog.String("requested-version", payload.PettiVer))
+// 	// 	return
+// 	// }
+// 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+// 		utils.WriteJSONError(w, http.StatusBadRequest, "невалидный JSON: "+err.Error())
+// 		return
+// 	}
+
+// 	if req.PettiVer == "" {
+// 		utils.WriteJSONError(w, http.StatusBadRequest, "отсутствует PettiVer")
+// 		return
+// 	}
+// 	if req.PettiVer != h.GetVersion() {
+// 		utils.WriteJSONError(w, http.StatusBadRequest, "неподдерживаемая версия PettiVer")
+// 		return
+// 	}
+// 	if req.PackageType.Request == "" {
+// 		utils.WriteJSONError(w, http.StatusBadRequest, "отсутствует PackageType.Request")
+// 		return
+// 	}
+// 	if req.Payload == nil {
+// 		utils.WriteJSONError(w, http.StatusBadRequest, "отсутствует Payload")
+// 		return
+// 	}
+// 	cmdRaw, ok := req.Payload["Exec"].(string)
+// 	if !ok || cmdRaw == "" {
+// 		utils.WriteJSONError(w, http.StatusBadRequest, "Payload.Exec отсутствует или некорректен")
+// 		return
+// 	}
+// 	cmd := cmdRaw
+
+// 	if !h.allowedCmd.MatchString(string([]rune(cmd)[0])) || !h.listAllowedCmd.MatchString(cmd) {
+// 		utils.WriteJSONError(w, http.StatusBadRequest, "команда запрещена")
+// 		return
+// 	}
+
+// 	// ===== Проверка скрипта
+// 	scriptPath := h.comMatch(h.GetVersion(), cmd)
+// 	if scriptPath == "" {
+// 		utils.WriteJSONError(w, http.StatusNotFound, "команда не найдена")
+// 		return
+// 	}
+// 	fullPath := filepath.Join(h.cfg.ComDir, scriptPath)
+// 	if _, err := os.Stat(fullPath); err != nil {
+// 		utils.WriteJSONError(w, http.StatusNotFound, "файл команды не найден")
+// 		return
+// 	}
+
+// 	// ===== Запуск Lua
+// 	L := lua.NewState()
+// 	defer L.Close()
+
+// 	inTable := L.NewTable()
+// 	paramsTable := L.NewTable()
+// 	if params, ok := req.Payload["PassedParameters"].(map[string]interface{}); ok {
+// 		for k, v := range params {
+// 			L.SetField(paramsTable, k, utils.ConvertGolangTypesToLua(L, v))
+// 		}
+// 	}
+// 	L.SetField(inTable, "Params", paramsTable)
+// 	L.SetGlobal("In", inTable)
+
+// 	resultTable := L.NewTable()
+// 	outTable := L.NewTable()
+// 	L.SetField(outTable, "Result", resultTable)
+// 	L.SetGlobal("Out", outTable)
+
+// 	prepareLua := filepath.Join(h.cfg.ComDir, "_prepare.lua")
+// 	if _, err := os.Stat(prepareLua); err == nil {
+// 		if err := L.DoFile(prepareLua); err != nil {
+// 			utils.WriteJSONError(w, http.StatusInternalServerError, "lua _prepare ошибка: "+err.Error())
+// 			return
+// 		}
+// 	}
+// 	if err := L.DoFile(fullPath); err != nil {
+// 		utils.WriteJSONError(w, http.StatusInternalServerError, "lua exec ошибка: "+err.Error())
+// 		return
+// 	}
+
+// 	lv := L.GetGlobal("Out")
+// 	tbl, ok := lv.(*lua.LTable)
+// 	if !ok {
+// 		utils.WriteJSONError(w, http.StatusInternalServerError, "'Out' не таблица")
+// 		return
+// 	}
+// 	resultVal := tbl.RawGetString("Result")
+// 	resultTbl, ok := resultVal.(*lua.LTable)
+// 	if !ok {
+// 		utils.WriteJSONError(w, http.StatusInternalServerError, "'Result' не таблица")
+// 		return
+// 	}
+
+// 	out := make(map[string]any)
+// 	resultTbl.ForEach(func(key lua.LValue, value lua.LValue) {
+// 		out[key.String()] = utils.ConvertLuaTypesToGolang(value)
+// 	})
+
+// 	uuid32, _ := corestate.GetNodeUUID(filepath.Join(config.MetaDir, "uuid"))
+
+// 	resp := PettiResponse{
+// 		PettiVer:             req.PettiVer,
+// 		ResponsibleAgentUUID: uuid32,
+// 		PackageType: struct {
+// 			AnswerOf string `json:"AnswerOf"`
+// 		}{AnswerOf: req.PackageType.Request},
+// 		Payload: map[string]any{
+// 			"RequestedCommand": cmd,
+// 			"Response":         out,
+// 		},
+// 	}
+
+// 	// ===== Финальная проверка на сериализацию (валидность сборки)
+// 	respData, err := json.Marshal(resp)
+// 	if err != nil {
+// 		utils.WriteJSONError(w, http.StatusInternalServerError, "внутренняя ошибка: пакет невалиден")
+// 		return
+// 	}
+
+// 	w.Header().Set("Content-Type", "application/json")
+// 	w.WriteHeader(http.StatusOK)
+// 	if _, err := w.Write(respData); err != nil {
+// 		h.log.Error("Ошибка при отправке JSON", slog.String("err", err.Error()))
+// 	}
+
+// 	// ===== Логгирование статуса
+// 	status, _ := out["status"].(string)
+// 	switch status {
+// 	case "ok":
+// 		h.log.Info("Успешно", slog.String("cmd", cmd), slog.Any("out", out))
+// 	case "error":
+// 		h.log.Warn("Ошибка в команде", slog.String("cmd", cmd), slog.Any("out", out))
+// 	default:
+// 		h.log.Info("Неизвестный статус", slog.String("cmd", cmd), slog.Any("out", out))
+// 	}
+// }
+
+/*
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+
+	"github.com/akyaiy/GoSally-mvp/core/config"
+	"github.com/akyaiy/GoSally-mvp/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/core/utils"
+	"github.com/go-chi/chi/v5"
+	lua "github.com/yuin/gopher-lua"
+)
+
+// HandlerV1 is the main handler for version 1 of the API.
+// The function processes the HTTP request and runs Lua scripts,
+// preparing the environment and subsequently transmitting the execution result
+func (h *HandlerV1) Handle(w http.ResponseWriter, r *http.Request) {
+	uuid16, err := utils.NewUUID(int(config.UUIDLength))
+	if err != nil {
+		h.log.Error("Failed to generate UUID",
+			slog.String("error", err.Error()))
+
+		if err := utils.WriteJSONError(w, http.StatusInternalServerError, "failed to generate UUID: "+err.Error()); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+	log := h.log.With(
+		slog.Group("request",
+			slog.String("version", h.GetVersion()),
+			slog.String("url", r.URL.String()),
+			slog.String("method", r.Method),
+		),
+		slog.Group("connection",
+			slog.String("connection-uuid", uuid16),
+			slog.String("remote", r.RemoteAddr),
+		),
+	)
+	log.Info("Received request")
+
+	cmd := chi.URLParam(r, "cmd")
+	if !h.allowedCmd.MatchString(string([]rune(cmd)[0])) || !h.listAllowedCmd.MatchString(cmd) {
+		log.Error("HTTP request error",
+			slog.String("error", "invalid command"),
+			slog.String("cmd", cmd),
+			slog.Int("status", http.StatusBadRequest))
+
+		if err := utils.WriteJSONError(w, http.StatusBadRequest, "invalid command"); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+
+	scriptPath := h.comMatch(chi.URLParam(r, "ver"), cmd)
+	if scriptPath == "" {
+		log.Error("HTTP request error",
+			slog.String("error", "command not found"),
+			slog.String("cmd", cmd),
+			slog.Int("status", http.StatusNotFound))
+
+		if err := utils.WriteJSONError(w, http.StatusNotFound, "command not found"); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+
+	scriptPath = filepath.Join(h.cfg.ComDir, scriptPath)
+	if _, err := os.Stat(scriptPath); err != nil {
+		log.Error("HTTP request error",
+			slog.String("error", "command not found"),
+			slog.String("cmd", cmd),
+			slog.Int("status", http.StatusNotFound))
+
+		if err := utils.WriteJSONError(w, http.StatusNotFound, "command not found"); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+
+	L := lua.NewState()
+	defer L.Close()
+
+	paramsTable := L.NewTable()
+	qt := r.URL.Query()
+	for k, v := range qt {
+		if len(v) > 0 {
+			L.SetField(paramsTable, k, lua.LString(v[0]))
+		}
+	}
+	inTable := L.NewTable()
+	L.SetField(inTable, "Params", paramsTable)
+	L.SetGlobal("In", inTable)
+
+	// Создаем таблицу Out с Result
+	resultTable := L.NewTable()
+	outTable := L.NewTable()
+	L.SetField(outTable, "Result", resultTable)
+	L.SetGlobal("Out", outTable)
+
+	prepareLuaEnv := filepath.Join(h.cfg.ComDir, "_prepare.lua")
+	if _, err := os.Stat(prepareLuaEnv); err == nil {
+		if err := L.DoFile(prepareLuaEnv); err != nil {
+			log.Error("Failed to prepare lua environment",
+				slog.String("error", err.Error()))
+
+			if err := utils.WriteJSONError(w, http.StatusInternalServerError, "lua error: "+err.Error()); err != nil {
+				h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+			}
+			return
+		}
+	} else {
+		log.Warn("No environment preparation script found, skipping preparation")
+	}
+
+	if err := L.DoFile(scriptPath); err != nil {
+		log.Error("Failed to execute lua script",
+			slog.String("error", err.Error()))
+		if err := utils.WriteJSONError(w, http.StatusInternalServerError, "lua error: "+err.Error()); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+
+	lv := L.GetGlobal("Out")
+	tbl, ok := lv.(*lua.LTable)
+	if !ok {
+		log.Error("Lua global 'Out' is not a table")
+
+		if err := utils.WriteJSONError(w, http.StatusInternalServerError, "'Out' is not a table"); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+
+	resultVal := tbl.RawGetString("Result")
+	resultTbl, ok := resultVal.(*lua.LTable)
+	if !ok {
+		log.Error("Lua global 'Result' is not a table")
+
+		if err := utils.WriteJSONError(w, http.StatusInternalServerError, "'Result' is not a table"); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+
+	out := make(map[string]any)
+	resultTbl.ForEach(func(key lua.LValue, value lua.LValue) {
+		out[key.String()] = utils.ConvertLuaTypesToGolang(value)
+	})
+	uuid32, _ := corestate.GetNodeUUID(filepath.Join(config.MetaDir, "uuid"))
+	response := ResponseFormat{
+		ResponsibleAgentUUID: uuid32,
+		RequestedCommand:     cmd,
+		Response:             out,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		log.Error("Failed to encode JSON response",
+			slog.String("error", err.Error()))
+	}
+
+	status, _ := out["status"].(string)
+	switch status {
+	case "error":
+		log.Info("Command executed with error",
+			slog.String("cmd", cmd),
+			slog.Any("result", out))
+	case "ok":
+		log.Info("Command executed successfully",
+			slog.String("cmd", cmd),
+			slog.Any("result", out))
+	default:
+		log.Info("Command executed and returned an unknown status",
+			slog.String("cmd", cmd),
+			slog.Any("result", out))
+	}
+
+	log.Info("Session completed")
+}
+*/
--- a/internal/server/sv1/handle_list.go
+++ b/internal/server/sv1/handle_list.go
@@ -0,0 +1,133 @@
+package sv1
+
+/*
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/akyaiy/GoSally-mvp/core/config"
+	"github.com/akyaiy/GoSally-mvp/core/corestate"
+	"github.com/akyaiy/GoSally-mvp/core/utils"
+	"github.com/go-chi/chi/v5"
+)
+
+// The function processes the HTTP request and returns a list of available commands.
+func (h *HandlerV1) HandleList(w http.ResponseWriter, r *http.Request) {
+	uuid16, err := utils.NewUUID(int(config.UUIDLength))
+	if err != nil {
+		h.log.Error("Failed to generate UUID",
+			slog.String("error", err.Error()))
+
+		if err := utils.WriteJSONError(w, http.StatusInternalServerError, "failed to generate UUID: "+err.Error()); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+	log := h.log.With(
+		slog.Group("request",
+			slog.String("version", h.GetVersion()),
+			slog.String("url", r.URL.String()),
+			slog.String("method", r.Method),
+		),
+		slog.Group("connection",
+			slog.String("connection-uuid", uuid16),
+			slog.String("remote", r.RemoteAddr),
+		),
+	)
+	log.Info("Received request")
+	type ComMeta struct {
+		Description string            `json:"Description"`
+		Arguments   map[string]string `json:"Arguments,omitempty"`
+	}
+	var (
+		files         []os.DirEntry
+		commands      = make(map[string]ComMeta)
+		cmdsProcessed = make(map[string]bool)
+	)
+
+	if files, err = os.ReadDir(h.cfg.ComDir); err != nil {
+		log.Error("Failed to read commands directory",
+			slog.String("error", err.Error()))
+
+		if err := utils.WriteJSONError(w, http.StatusInternalServerError, "failed to read commands directory: "+err.Error()); err != nil {
+			h.log.Error("Failed to write JSON", slog.String("err", err.Error()))
+		}
+		return
+	}
+
+	apiVer := chi.URLParam(r, "ver")
+
+	// Сначала ищем версионные
+	for _, file := range files {
+		if file.IsDir() || filepath.Ext(file.Name()) != ".lua" {
+			continue
+		}
+		cmdFull := file.Name()[:len(file.Name())-4]
+		cmdParts := strings.SplitN(cmdFull, "?", 2)
+		cmdName := cmdParts[0]
+
+		if !h.allowedCmd.MatchString(string([]rune(cmdName)[0])) {
+			continue
+		}
+		if !h.listAllowedCmd.MatchString(cmdName) {
+			continue
+		}
+
+		if len(cmdParts) == 2 && cmdParts[1] == apiVer {
+			description, _ := h.extractDescriptionStatic(filepath.Join(h.cfg.ComDir, file.Name()))
+			if description == "" {
+				description = "description missing"
+			}
+			commands[cmdName] = ComMeta{Description: description}
+			cmdsProcessed[cmdName] = true
+		}
+	}
+
+	// Потом фоллбеки
+	for _, file := range files {
+		if file.IsDir() || filepath.Ext(file.Name()) != ".lua" {
+			continue
+		}
+		cmdFull := file.Name()[:len(file.Name())-4]
+		cmdParts := strings.SplitN(cmdFull, "?", 2)
+		cmdName := cmdParts[0]
+
+		if !h.allowedCmd.MatchString(string([]rune(cmdName)[0])) {
+			continue
+		}
+		if !h.listAllowedCmd.MatchString(cmdName) {
+			continue
+		}
+		if cmdsProcessed[cmdName] {
+			continue
+		}
+		if len(cmdParts) == 1 {
+			description, _ := h.extractDescriptionStatic(filepath.Join(h.cfg.ComDir, file.Name()))
+			if description == "" {
+				description = "description missing"
+			}
+			commands[cmdName] = ComMeta{Description: description}
+			cmdsProcessed[cmdName] = true
+		}
+	}
+
+	log.Debug("Command list prepared")
+
+	log.Info("Session completed")
+	uuid32, _ := corestate.GetNodeUUID(filepath.Join(config.MetaDir, "uuid"))
+	response := ResponseFormat{
+		ResponsibleAgentUUID: uuid32,
+		RequestedCommand:     "list",
+		Response:             commands,
+	}
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(response); err != nil {
+		h.log.Error("Failed to write JSON error response",
+			slog.String("error", err.Error()))
+	}
+}
+*/
--- a/internal/server/sv1/petti.go
+++ b/internal/server/sv1/petti.go
@@ -0,0 +1,20 @@
+package sv1
+
+// PETTI - Go Sally Protocol for Exchanging Technical Tasks and Information
+
+type PettiRequest struct {
+	PettiVer    string `json:"PettiVer"`
+	PackageType struct {
+		Request string `json:"Request"`
+	} `json:"PackageType"`
+	Payload map[string]any `json:"Payload"`
+}
+
+type PettiResponse struct {
+	PettiVer    string `json:"PettiVer"`
+	PackageType struct {
+		AnswerOf string `json:"AnswerOf"`
+	} `json:"PackageType"`
+	ResponsibleAgentUUID string         `json:"ResponsibleAgentUUID"`
+	Payload              map[string]any `json:"Payload"`
+}
--- a/internal/server/sv1/server.go
+++ b/internal/server/sv1/server.go
@@ -0,0 +1,51 @@
+// 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 (
+	"log/slog"
+	"regexp"
+
+	"github.com/akyaiy/GoSally-mvp/internal/engine/config"
+)
+
+// HandlerV1InitStruct structure is only for initialization
+type HandlerV1InitStruct struct {
+	Ver            string
+	Log            slog.Logger
+	Config         *config.Conf
+	AllowedCmd     *regexp.Regexp
+	ListAllowedCmd *regexp.Regexp
+}
+
+// HandlerV1 implements the ServerV1UtilsContract and serves as the main handler for API requests.
+type HandlerV1 struct {
+	log *slog.Logger
+
+	cfg *config.Conf
+
+	// allowedCmd and listAllowedCmd are regular expressions used to validate command names.
+	allowedCmd     *regexp.Regexp
+	listAllowedCmd *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{
+		log:            &o.Log,
+		cfg:            o.Config,
+		allowedCmd:     o.AllowedCmd,
+		listAllowedCmd: o.ListAllowedCmd,
+		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/internal/server/sv1/utils.go
+++ b/internal/server/sv1/utils.go
@@ -0,0 +1,60 @@
+package sv1
+
+import (
+	"log/slog"
+	"os"
+)
+
+// func (h *HandlerV1) errNotFound(w http.ResponseWriter, r *http.Request) {
+// 	utils.WriteJSONError(h.w, http.StatusBadRequest, "invalid request")
+// 	h.log.Error("HTTP request error",
+// 		slog.String("remote", h.r.RemoteAddr),
+// 		slog.String("method", h.r.Method),
+// 		slog.String("url", h.r.URL.String()),
+// 		slog.Int("status", http.StatusBadRequest))
+// }
+
+// func (h *HandlerV1) extractDescriptionStatic(path string) (string, error) {
+// 	data, err := os.ReadFile(path)
+// 	if err != nil {
+// 		return "", err
+// 	}
+
+// 	re := regexp.MustCompile(`---\s*#description\s*=\s*"([^"]+)"`)
+// 	m := re.FindStringSubmatch(string(data))
+// 	if len(m) <= 0 {
+// 		return "", nil
+// 	}
+// 	return m[1], nil
+// }
+
+func (h *HandlerV1) comMatch(ver string, comName string) string {
+	files, err := os.ReadDir(h.cfg.ComDir)
+	if err != nil {
+		h.log.Error("Failed to read com dir",
+			slog.String("error", err.Error()))
+		return ""
+	}
+
+	baseName := comName + ".lua"
+	verName := comName + "?" + ver + ".lua"
+
+	var baseFileFound string
+
+	for _, f := range files {
+		if f.IsDir() {
+			continue
+		}
+		fname := f.Name()
+
+		if fname == verName {
+			return fname
+		}
+
+		if fname == baseName {
+			baseFileFound = fname
+		}
+	}
+
+	return baseFileFound
+}