fmt

src/hooks/run.go

@@ -11,8 +11,8 @@ import (
 	"regexp"
 	"time"
 
-	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
 	"github.com/akyaiy/GoSally-mvp/src/internal/colors"
+	"github.com/akyaiy/GoSally-mvp/src/internal/core/corestate"
 	"github.com/akyaiy/GoSally-mvp/src/internal/core/run_manager"
 	"github.com/akyaiy/GoSally-mvp/src/internal/core/update"
 	"github.com/akyaiy/GoSally-mvp/src/internal/core/utils"
@@ -22,6 +22,7 @@ import (
 	"github.com/akyaiy/GoSally-mvp/src/internal/server/gateway"
 	"github.com/akyaiy/GoSally-mvp/src/internal/server/session"
 	"github.com/akyaiy/GoSally-mvp/src/internal/server/sv1"
+	"github.com/akyaiy/GoSally-mvp/src/internal/server/sv2"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/cors"
 	"github.com/spf13/cobra"
@@ -65,13 +66,20 @@ func RunHook(ctx context.Context, cs *corestate.CoreState, x *app.AppX) error {
 		Ver:        "v1",
 	})
 
+	sv2 := sv2.InitServer(&sv2.HandlerInitStruct{
+		X:          x,
+		CS:         cs,
+		AllowedCmd: regexp.MustCompile(AllowedCmdPattern),
+		Ver:        "v2",
+	})
+
 	session_manager := session.New(*x.Config.Conf.HTTPServer.SessionTTL)
 
 	s := gateway.InitGateway(&gateway.GatewayServerInit{
 		SM: session_manager,
 		CS: cs,
 		X:  x,
-	}, serverv1)
+	}, serverv1, sv2)
 
 	r := chi.NewRouter()
 	r.Use(cors.Handler(cors.Options{

src/internal/engine/lua/types.go

@@ -11,13 +11,12 @@ import (
 type LuaEngineDeps struct {
 	HttpRequest    *http.Request
 	JSONRPCRequest *rpc.RPCRequest
-	SessionUUID string
+	SessionUUID    string
-	ScriptPath string
+	ScriptPath     string
 }
 
 type LuaEngineContract interface {
 	Handle(deps *LuaEngineDeps) *rpc.RPCResponse
-	
 }
 
 type LuaEngine struct {

src/internal/server/sv1/db_sqlite.go

@@ -80,10 +80,10 @@ func loadDBMod(llog *slog.Logger, sid string) func(*lua.LState) int {
 
 		mt := L.NewTypeMetatable("gosally_db")
 		L.SetField(mt, "__index", L.SetFuncs(L.NewTable(), map[string]lua.LGFunction{
-			"exec":  dbExec,
+			"exec":      dbExec,
-			"query": dbQuery,
+			"query":     dbQuery,
 			"query_row": dbQueryRow,
-			"close": dbClose,
+			"close":     dbClose,
 		}))
 
 		L.SetField(dbMod, "__seed", lua.LString(sid))
@@ -215,43 +215,43 @@ func dbExec(L *lua.LState) int {
 }
 
 func dbQueryRow(L *lua.LState) int {
-    ud := L.CheckUserData(1)
+	ud := L.CheckUserData(1)
-    conn, ok := ud.Value.(*DBConnection)
+	conn, ok := ud.Value.(*DBConnection)
-    if !ok {
+	if !ok {
-        L.Push(lua.LNil)
+		L.Push(lua.LNil)
-        L.Push(lua.LString("invalid database connection"))
+		L.Push(lua.LString("invalid database connection"))
-        return 2
+		return 2
-    }
+	}
 
-    query := L.CheckString(2)
+	query := L.CheckString(2)
 
-    var args []any
+	var args []any
-    if L.GetTop() >= 3 {
+	if L.GetTop() >= 3 {
-        params := L.CheckTable(3)
+		params := L.CheckTable(3)
-        params.ForEach(func(k lua.LValue, v lua.LValue) {
+		params.ForEach(func(k lua.LValue, v lua.LValue) {
-            args = append(args, ConvertLuaTypesToGolang(v))
+			args = append(args, ConvertLuaTypesToGolang(v))
-        })
+		})
-    }
+	}
 
-    if conn.log {
+	if conn.log {
-        conn.logger.Info("DB QueryRow",
+		conn.logger.Info("DB QueryRow",
-            slog.String("query", query),
+			slog.String("query", query),
-            slog.Any("params", args))
+			slog.Any("params", args))
-    }
+	}
 
-    mtx := getDBMutex(conn.dbPath)
+	mtx := getDBMutex(conn.dbPath)
-    mtx.RLock()
+	mtx.RLock()
-    defer mtx.RUnlock()
+	defer mtx.RUnlock()
 
-    db, err := sql.Open("sqlite", conn.dbPath+"?_busy_timeout=5000&_journal_mode=WAL&_sync=NORMAL&_cache_size=-10000")
+	db, err := sql.Open("sqlite", conn.dbPath+"?_busy_timeout=5000&_journal_mode=WAL&_sync=NORMAL&_cache_size=-10000")
-    if err != nil {
+	if err != nil {
-        L.Push(lua.LNil)
+		L.Push(lua.LNil)
-        L.Push(lua.LString(err.Error()))
+		L.Push(lua.LString(err.Error()))
-        return 2
+		return 2
-    }
+	}
-    defer db.Close()
+	defer db.Close()
 
-    row := db.QueryRow(query, args...)
+	row := db.QueryRow(query, args...)
 
 	columns := []string{}
 	stmt, err := db.Prepare(query)
@@ -278,36 +278,36 @@ func dbQueryRow(L *lua.LState) int {
 		columns = append(columns, c)
 	}
 
-    colCount := len(columns)
+	colCount := len(columns)
-    values := make([]any, colCount)
+	values := make([]any, colCount)
-    valuePtrs := make([]any, colCount)
+	valuePtrs := make([]any, colCount)
-    for i := range columns {
+	for i := range columns {
-        valuePtrs[i] = &values[i]
+		valuePtrs[i] = &values[i]
-    }
+	}
 
-    err = row.Scan(valuePtrs...)
+	err = row.Scan(valuePtrs...)
-    if err != nil {
+	if err != nil {
-        if err == sql.ErrNoRows {
+		if err == sql.ErrNoRows {
-            L.Push(lua.LNil)
+			L.Push(lua.LNil)
-            return 1
+			return 1
-        }
+		}
-        L.Push(lua.LNil)
+		L.Push(lua.LNil)
-        L.Push(lua.LString(fmt.Sprintf("scan failed: %v", err)))
+		L.Push(lua.LString(fmt.Sprintf("scan failed: %v", err)))
-        return 2
+		return 2
-    }
+	}
 
-    rowTable := L.NewTable()
+	rowTable := L.NewTable()
-    for i, col := range columns {
+	for i, col := range columns {
-        val := values[i]
+		val := values[i]
-        if val == nil {
+		if val == nil {
-            L.SetField(rowTable, col, lua.LNil)
+			L.SetField(rowTable, col, lua.LNil)
-        } else {
+		} else {
-            L.SetField(rowTable, col, ConvertGolangTypesToLua(L, val))
+			L.SetField(rowTable, col, ConvertGolangTypesToLua(L, val))
-        }
+		}
-    }
+	}
 
-    L.Push(rowTable)
+	L.Push(rowTable)
-    return 1
+	return 1
 }
 
 func dbQuery(L *lua.LState) int {

src/internal/server/sv2/handle.go

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

src/internal/server/sv2/server.go

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