using CURRENT_ARCH_NORMALIZED

Solved Issue #3

go.mod

@@ -0,0 +1,7 @@
+module github.com/roboogg133/packets
+
+go 1.25.3
+
+require github.com/yuin/gopher-lua v1.1.1
+
+require github.com/klauspost/compress v1.18.1

go.sum

@@ -0,0 +1,4 @@
+github.com/klauspost/compress v1.18.1 h1:bcSGx7UbpBqMChDtsF28Lw6v/G94LPrrbMbdC3JH2co=
+github.com/klauspost/compress v1.18.1/go.mod h1:ZQFFVG+MdnR0P+l6wpXgIL4NTtwiKIdBnrBd8Nrxr+0=
+github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
+github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=

internal/lua/luafunctions.go

@@ -0,0 +1,120 @@
+package lua
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+func LRemove(L *lua.LState) int {
+	filename := L.CheckString(1)
+
+	err := os.RemoveAll(filename)
+	if err != nil {
+		L.Push(lua.LFalse)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+	L.Push(lua.LTrue)
+	L.Push(lua.LNil)
+	return 2
+}
+
+func LRename(L *lua.LState) int {
+	oldname := L.CheckString(1)
+	newname := L.CheckString(2)
+
+	if err := os.Rename(oldname, newname); err != nil {
+		L.Push(lua.LFalse)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+
+	L.Push(lua.LTrue)
+	return 1
+}
+func LCopy(L *lua.LState) int {
+	oldname := L.CheckString(1)
+	newname := L.CheckString(2)
+
+	if err := copyDir(oldname, newname); err != nil {
+		L.Push(lua.LFalse)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+
+	L.Push(lua.LTrue)
+	L.Push(lua.LNil)
+	return 2
+
+}
+
+func LSymlink(L *lua.LState) int {
+	fileName := L.CheckString(1)
+	destination := L.CheckString(2)
+
+	_ = os.RemoveAll(destination)
+	if err := os.Symlink(fileName, destination); err != nil {
+		L.Push(lua.LFalse)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+
+	L.Push(lua.LTrue)
+	L.Push(lua.LNil)
+	return 2
+}
+
+func Ljoin(L *lua.LState) int {
+
+	n := L.GetTop()
+	parts := make([]string, 0, n)
+
+	for i := 1; i <= n; i++ {
+		val := L.Get(i)
+		parts = append(parts, val.String())
+	}
+
+	result := filepath.Join(parts...)
+	L.Push(lua.LString(result))
+	return 1
+}
+
+func LMkdir(L *lua.LState) int {
+	path := L.CheckString(1)
+	perm := L.CheckInt(2)
+
+	if err := os.MkdirAll(path, os.FileMode(perm)); err != nil {
+		L.Push(lua.LFalse)
+		L.Push(lua.LString(err.Error()))
+		return 2
+	}
+
+	L.Push(lua.LTrue)
+	L.Push(lua.LNil)
+	return 2
+}
+
+func LError(L *lua.LState) int {
+	n := L.GetTop()
+	parts := make([]any, 0, n)
+
+	for i := 1; i <= n; i++ {
+		val := L.Get(i)
+		parts = append(parts, val.String())
+	}
+
+	llogger().Panic(parts...)
+	return 0
+}
+
+func LSetEnv(L *lua.LState) int {
+	env := L.CheckString(1)
+	value := L.CheckString(2)
+	os.Setenv(env, value)
+	return 0
+}
+
+func llogger() *log.Logger { return log.New(os.Stderr, "script error: ", 0) }

internal/lua/utils.go

@@ -0,0 +1,95 @@
+package lua
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+)
+
+func copyDir(src string, dest string) error {
+	if stats, err := os.Stat(src); err != nil {
+		return err
+	} else {
+		if stats.IsDir() {
+			files, err := os.ReadDir(src)
+			if err != nil {
+				return err
+			}
+
+			if err := os.MkdirAll(dest, 0o755); err != nil {
+				return err
+			}
+
+			for _, file := range files {
+				if file.IsDir() {
+					copyDir(filepath.Join(src, file.Name()), filepath.Join(dest, file.Name()))
+					continue
+				}
+				srcFile := filepath.Join(src, file.Name())
+
+				f, err := os.Create(filepath.Join(dest, file.Name()))
+				if err != nil {
+					return err
+				}
+				defer f.Close()
+
+				opennedSrcFile, err := os.Open(srcFile)
+				if err != nil {
+					return err
+				}
+				defer opennedSrcFile.Close()
+				if _, err := io.Copy(f, opennedSrcFile); err != nil {
+					return err
+				}
+
+			}
+		} else {
+			if err := copyFile(src, dest); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func copyFile(source string, destination string) error {
+	src, err := os.Open(source)
+	if err != nil {
+		return err
+	}
+	defer src.Close()
+
+	status, err := src.Stat()
+	if err != nil {
+		return err
+	}
+
+	err = os.MkdirAll(filepath.Dir(destination), 0o755)
+	if err != nil {
+		return err
+	}
+
+	dst, err := os.Create(destination)
+	if err != nil {
+		if !os.IsExist(err) {
+			dst, err = os.Open(destination)
+			if err != nil {
+				return err
+			}
+		} else {
+			return err
+		}
+	}
+
+	defer dst.Close()
+	if err := dst.Chmod(status.Mode()); err != nil {
+		return err
+	}
+
+	_, err = io.Copy(dst, src)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

main.go

@@ -0,0 +1,10 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+)
+
+func main() {
+	fmt.Println(runtime.GOARCH)
+}

pkg/packet.lua.d/auxiliar_functions.go

@@ -0,0 +1,344 @@
+package packet
+
+import (
+	"strings"
+
+	lua "github.com/yuin/gopher-lua"
+)
+
+func getStringFromTable(table *lua.LTable, key string) string {
+	value := table.RawGetString(key)
+	if value.Type() == lua.LTString {
+		return value.String()
+	}
+	return ""
+}
+
+func getIntFromTable(table *lua.LTable, key string) int {
+	value := table.RawGetString(key)
+	if value.Type() == lua.LTNumber {
+		if num, ok := value.(lua.LNumber); ok {
+			return int(num)
+		}
+	}
+	return -133
+}
+
+func getStringArrayFromTable(table *lua.LTable, key string) []string {
+	value := table.RawGetString(key)
+	if value.Type() != lua.LTTable {
+		return []string{}
+	}
+
+	arrayTable := value.(*lua.LTable)
+	var result []string
+
+	arrayTable.ForEach(func(_, value lua.LValue) {
+		if value.Type() == lua.LTString {
+			result = append(result, value.String())
+		}
+	})
+
+	return result
+}
+
+func getFunctionFromTable(table *lua.LTable, key string) *lua.LFunction {
+	value := table.RawGetString(key)
+	if value.Type() == lua.LTFunction {
+		return value.(*lua.LFunction)
+	}
+	return nil
+}
+
+type version struct {
+	Name       string
+	Constraint VersionConstraint
+}
+
+func getDependenciesFromTable(table *lua.LTable, key string) *PkgDependencies {
+	value := table.RawGetString(key)
+	if value.Type() != lua.LTTable {
+		return &PkgDependencies{}
+	}
+
+	var pkgDeps PkgDependencies
+
+	depnTable := value.(*lua.LTable)
+
+	pkgDeps.RuntimeDependencies = depsParse(depnTable, "runtime")
+	pkgDeps.BuildDependencies = depsParse(depnTable, "build")
+	pkgDeps.Conflicts = depsParse(depnTable, "conflicts")
+
+	return &pkgDeps
+}
+
+func getSourcesFromTable(table *lua.LTable, key string) *[]Source {
+	value := table.RawGetString(key)
+	if value.Type() != lua.LTTable {
+		return nil
+	}
+
+	var srcList []Source
+
+	srcTable := value.(*lua.LTable)
+
+	srcTable.ForEach(func(_, value lua.LValue) {
+		if value.Type() == lua.LTTable {
+			src := value.(*lua.LTable)
+
+			var srcInfo Source
+
+			method := src.RawGetString("method")
+			if method.Type() == lua.LTString {
+				srcInfo.Method = method.String()
+			}
+
+			url := src.RawGetString("url")
+
+			if url.Type() == lua.LTString {
+				srcInfo.Url = url.String()
+			}
+
+		switchlabel:
+			switch srcInfo.Method {
+			case "GET":
+				var getSpecs GETSpecs
+
+				getSpecs.SHA256 = new(string)
+				sha256sumL := src.RawGetString("sha256")
+				if sha256sumL.Type() == lua.LTString {
+					*getSpecs.SHA256 = sha256sumL.String()
+				}
+
+				headersLT := src.RawGetString("headers")
+				if headersLT.Type() == lua.LTTable {
+
+					headers := headersLT.(*lua.LTable)
+
+					tmpMap := make(map[string]string)
+					headers.ForEach(func(headerKey, value lua.LValue) {
+						if value.Type() == lua.LTString {
+							tmpMap[headerKey.String()] = value.String()
+						}
+					})
+
+					getSpecs.Headers = &tmpMap
+				}
+				srcInfo.Specs = getSpecs
+				break switchlabel
+
+			case "git":
+				var gitSpecs GitSpecs
+
+				branchL := src.RawGetString("branch")
+
+				if branchL.Type() == lua.LTString {
+					gitSpecs.Branch = branchL.String()
+				}
+
+				tagL := src.RawGetString("tag")
+
+				if tagL.Type() == lua.LTString {
+					*gitSpecs.Tag = tagL.String()
+				}
+
+				srcInfo.Specs = gitSpecs
+				break switchlabel
+			case "POST":
+				var postSpecs POSTSpecs
+
+				sha256sumL := src.RawGetString("sha256")
+				if sha256sumL.Type() == lua.LTString {
+					*postSpecs.SHA256 = sha256sumL.String()
+				}
+
+				headersLT := src.RawGetString("headers")
+				if headersLT.Type() == lua.LTTable {
+
+					headers := headersLT.(*lua.LTable)
+
+					tmpMap := make(map[string]string)
+					headers.ForEach(func(headerKey, value lua.LValue) {
+						if value.Type() == lua.LTString {
+							tmpMap[headerKey.String()] = value.String()
+						}
+					})
+
+					postSpecs.Headers = &tmpMap
+				}
+
+				bodyLt := src.RawGetString("body")
+
+				if bodyLt.Type() == lua.LTString {
+					*postSpecs.Body = bodyLt.String()
+				}
+
+				srcInfo.Specs = postSpecs
+				break switchlabel
+			}
+			srcList = append(srcList, srcInfo)
+		}
+	})
+
+	return &srcList
+}
+
+func getPlataformsFromTable(table *lua.LTable, key string) *map[OperationalSystem]Plataform {
+	value := table.RawGetString(key)
+
+	if value.Type() != lua.LTTable {
+		return nil
+	}
+
+	tmpMap := make(map[OperationalSystem]Plataform)
+
+	plataform := value.(*lua.LTable)
+
+	plataform.ForEach(func(osString, value lua.LValue) {
+		if value.Type() != lua.LTTable {
+			return
+		}
+
+		var plat Plataform
+		plat.Architetures = getStringArrayFromTable(value.(*lua.LTable), "arch")
+		plat.Name = osString.String()
+		plat.Sources = getSourcesFromTable(value.(*lua.LTable), "sources")
+		plat.Dependencies = getDependenciesFromTable(value.(*lua.LTable), "dependencies")
+
+		tmpMap[OperationalSystem(osString.String())] = plat
+	})
+
+	if len(tmpMap) == 0 {
+		return nil
+	}
+
+	return &tmpMap
+}
+
+func depsParse(depnTable *lua.LTable, key string) *map[string]*VersionConstraint {
+	if runLTable := depnTable.RawGetString(key); runLTable.Type() == lua.LTTable {
+		runtimeTable := runLTable.(*lua.LTable)
+
+		mapTemp := make(map[string]*VersionConstraint)
+
+		var found bool
+
+		runtimeTable.ForEach(func(_, value lua.LValue) {
+			if value.Type() == lua.LTString {
+				version := parseVersionString(value.String())
+				mapTemp[version.Name] = &version.Constraint
+				found = true
+			}
+		})
+		if !found {
+			return nil
+		} else {
+			return &mapTemp
+		}
+
+	}
+	return nil
+}
+
+func parseVersionString(s string) version {
+	// >=go@1.25.3 | <=go@1.25.3 | go | >go@1.25.3 | <go@1.25.3 | go@1.25.3
+	if strings.ContainsAny(s, "@") {
+		slice := strings.Split(s, "@")
+
+		switch {
+		case !strings.ContainsAny(s, "<=>"):
+			return version{
+				Name:       slice[0],
+				Constraint: VersionConstraint(slice[1]),
+			}
+		case s[0] == '>' && s[1] == '=':
+
+			return version{
+				Name:       slice[0][2:],
+				Constraint: VersionConstraint(">=" + slice[1]),
+			}
+		case s[0] == '<' && s[1] == '=':
+
+			return version{
+				Name:       slice[0][2:],
+				Constraint: VersionConstraint("<=" + slice[1]),
+			}
+
+		case s[0] == '>' && s[1] != '=':
+
+			return version{
+				Name:       slice[0][1:],
+				Constraint: VersionConstraint(">" + slice[1]),
+			}
+		case s[0] == '<' && s[1] != '=':
+
+			return version{
+				Name:       slice[0][1:],
+				Constraint: VersionConstraint("<" + slice[1]),
+			}
+		}
+
+	} else if !strings.ContainsAny(s, "@=<>") {
+		return version{
+			Name:       s,
+			Constraint: VersionConstraint(0x000),
+		}
+	}
+
+	return version{}
+}
+
+func normalizeArch(arch string) string {
+	switch arch {
+	case "386":
+		return "i686"
+	case "amd64":
+		return "x86_64"
+	case "amd64p32":
+		return "x86_64"
+	case "arm":
+		return "arm"
+	case "arm64":
+		return "aarch64"
+	case "arm64be":
+		return "aarch64_be"
+	case "armbe":
+		return "armbe"
+	case "loong64":
+		return "loongarch64"
+	case "mips":
+		return "mips"
+	case "mips64":
+		return "mips64"
+	case "mips64le":
+		return "mips64el"
+	case "mips64p32":
+		return "mips64"
+	case "mips64p32le":
+		return "mips64el"
+	case "mipsle":
+		return "mipsel"
+	case "ppc":
+		return "powerpc"
+	case "ppc64":
+		return "ppc64"
+	case "ppc64le":
+		return "ppc64le"
+	case "riscv":
+		return "riscv"
+	case "riscv64":
+		return "riscv64"
+	case "s390":
+		return "s390"
+	case "s390x":
+		return "s390x"
+	case "sparc":
+		return "sparc"
+	case "sparc64":
+		return "sparc64"
+	case "wasm":
+		return "wasm"
+	default:
+		return arch
+	}
+}

pkg/packet.lua.d/config.go

@@ -0,0 +1,39 @@
+package packet
+
+type Config struct {
+	BinDir *string
+}
+
+const defaultBinDir = "/usr/bin"
+
+func checkConfig(cfg *Config) *Config {
+	if cfg == nil {
+		bin := defaultBinDir
+		return &Config{
+			BinDir: &bin,
+		}
+	}
+	if *cfg.BinDir == "" || cfg.BinDir == nil {
+		bin := defaultBinDir
+		return &Config{
+			BinDir: &bin,
+		}
+	} else {
+		return cfg
+	}
+
+}
+func checkConfigSrc(cfg *GetSourceConfig) *GetSourceConfig {
+	if cfg == nil {
+		return nil
+	}
+
+	switch {
+	case *cfg.PacketDir == "" || cfg.PacketDir == nil:
+		s := randStringBytes(12)
+		cfg.PacketDir = &s
+	}
+
+	return cfg
+
+}

pkg/packet.lua.d/main.go

@@ -0,0 +1,267 @@
+package packet
+
+import (
+	"archive/tar"
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"path/filepath"
+	"runtime"
+	"time"
+
+	"github.com/klauspost/compress/zstd"
+
+	lua_utils "github.com/roboogg133/packets/internal/lua"
+	lua "github.com/yuin/gopher-lua"
+)
+
+type OperationalSystem string
+
+type PacketLua struct {
+	Name        string
+	Version     string
+	Maintaner   string
+	Description string
+	Serial      int
+
+	Plataforms         *map[OperationalSystem]Plataform
+	GlobalSources      *[]Source
+	GlobalDependencies *PkgDependencies
+
+	Build     *lua.LFunction
+	Install   *lua.LFunction
+	PreRemove *lua.LFunction
+}
+
+type Source struct {
+	Method string
+	Url    string
+	Specs  any
+}
+
+type VersionConstraint string
+
+type PkgDependencies struct {
+	RuntimeDependencies *map[string]*VersionConstraint
+	BuildDependencies   *map[string]*VersionConstraint
+	Conflicts           *map[string]*VersionConstraint
+}
+
+type Plataform struct {
+	Name         string
+	Architetures []string
+	Sources      *[]Source
+	Dependencies *PkgDependencies
+}
+
+type GitSpecs struct {
+	Branch string
+	Tag    *string
+}
+
+type POSTSpecs struct {
+	SHA256  *string
+	Body    *string
+	Headers *map[string]string
+}
+
+type GETSpecs struct {
+	SHA256  *string
+	Headers *map[string]string
+}
+
+var ErrCantFindPacketDotLua = errors.New("can't find Packet.lua in .tar.zst file")
+var ErrFileDontReturnTable = errors.New("invalid Packet.lua format: the file do not return a table")
+var ErrCannotFindPackageTable = errors.New("invalid Packet.lua format: can't find package table")
+var ErrInstallFunctionDoesNotExist = errors.New("can not find instal()")
+var ErrSha256Sum = errors.New("false checksum")
+
+// ReadPacket read a Packet.lua and alredy set global vars
+func ReadPacket(f []byte, cfg *Config) (PacketLua, error) {
+	cfg = checkConfig(cfg)
+
+	L := lua.NewState()
+	defer L.Close()
+
+	osObject := L.GetGlobal("os").(*lua.LTable)
+	osObject.RawSetString("setenv", L.NewFunction(lua_utils.LSetEnv))
+	ioObject := L.GetGlobal("io").(*lua.LTable)
+
+	L.SetGlobal("os", lua.LNil)
+	L.SetGlobal("io", lua.LNil)
+
+	L.SetGlobal("BIN_DIR", lua.LString(*cfg.BinDir))
+	L.SetGlobal("CURRENT_ARCH", lua.LString(runtime.GOARCH))
+	L.SetGlobal("CURRENT_ARCH_NORMALIZED", lua.LString(normalizeArch(runtime.GOARCH)))
+	L.SetGlobal("CURRENT_PLATAFORM", lua.LString(runtime.GOOS))
+
+	L.SetGlobal("pathjoin", L.NewFunction(lua_utils.Ljoin))
+
+	if err := L.DoString(string(f)); err != nil {
+		return PacketLua{}, err
+	}
+
+	L.SetGlobal("os", osObject)
+	L.SetGlobal("io", ioObject)
+
+	tableLua := L.Get(-1)
+
+	if tableLua.Type() != lua.LTTable {
+		return PacketLua{}, ErrFileDontReturnTable
+	}
+
+	table := tableLua.(*lua.LTable)
+
+	pkgTableLua := table.RawGetString("package")
+	if pkgTableLua.Type() != lua.LTTable {
+		return PacketLua{}, ErrCannotFindPackageTable
+	}
+	pkgTable := pkgTableLua.(*lua.LTable)
+
+	packetLua := &PacketLua{
+		Name:        getStringFromTable(pkgTable, "name"),
+		Version:     getStringFromTable(pkgTable, "version"),
+		Maintaner:   getStringFromTable(pkgTable, "maintainer"),
+		Description: getStringFromTable(pkgTable, "description"),
+		Serial:      getIntFromTable(pkgTable, "serial"),
+
+		Plataforms: getPlataformsFromTable(pkgTable, "plataforms"),
+
+		GlobalDependencies: getDependenciesFromTable(pkgTable, "build_dependencies"),
+		GlobalSources:      getSourcesFromTable(pkgTable, "sources"),
+
+		Build:     getFunctionFromTable(table, "build"),
+		Install:   getFunctionFromTable(table, "install"),
+		PreRemove: getFunctionFromTable(table, "pre_remove"),
+	}
+
+	if packetLua.Install == nil {
+		return PacketLua{}, ErrInstallFunctionDoesNotExist
+	}
+
+	return *packetLua, nil
+}
+
+func ReadPacketFromZSTDF(file io.Reader, cfg *Config) (PacketLua, error) {
+	cfg = checkConfig(cfg)
+
+	zstdReader, err := zstd.NewReader(file)
+	if err != nil {
+		return PacketLua{}, err
+	}
+	defer zstdReader.Close()
+
+	tarReader := tar.NewReader(zstdReader)
+	for {
+		header, err := tarReader.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return PacketLua{}, err
+		}
+
+		if filepath.Base(header.Name) == "Packet.lua" {
+
+			packageLuaBlob, err := io.ReadAll(tarReader)
+			if err != nil {
+				return PacketLua{}, err
+			}
+
+			return ReadPacket(packageLuaBlob, cfg)
+		}
+
+	}
+	return PacketLua{}, ErrCantFindPacketDotLua
+}
+
+type GetSourceConfig struct {
+	PacketDir *string
+}
+
+func GetSource(url, method string, info any) ([]byte, error) {
+
+	switch method {
+	case "GET":
+		req, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			return nil, err
+		}
+
+		specs := info.(GETSpecs)
+
+		for k, v := range *specs.Headers {
+			req.Header.Set(k, v)
+		}
+
+		client := http.Client{Timeout: 5 * time.Minute}
+
+		resp, err := client.Do(req)
+		if err != nil {
+			return nil, err
+		}
+
+		defer resp.Body.Close()
+
+		data, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return nil, err
+		}
+
+		if !verifySHA256(*specs.SHA256, data) {
+			return nil, ErrSha256Sum
+		}
+
+		return data, nil
+	case "POST":
+		specs := info.(POSTSpecs)
+		var body *bytes.Reader
+
+		if specs.Body != nil {
+			body = bytes.NewReader([]byte(*specs.Body))
+		} else {
+			body = nil
+		}
+		req, err := http.NewRequest("POST", url, body)
+		if err != nil {
+			return nil, err
+		}
+
+		for k, v := range *specs.Headers {
+			req.Header.Set(k, v)
+		}
+
+		client := http.Client{Timeout: 5 * time.Minute}
+
+		resp, err := client.Do(req)
+		if err != nil {
+			return nil, err
+		}
+
+		defer resp.Body.Close()
+
+		data, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return nil, err
+		}
+
+		if !verifySHA256(*specs.SHA256, data) {
+			return nil, ErrSha256Sum
+		}
+
+		return data, nil
+	}
+
+	return nil, fmt.Errorf("invalid method")
+}
+
+func verifySHA256(checksum string, src []byte) bool {
+
+	check := sha256.Sum256(src)
+
+	return hex.EncodeToString(check[:]) == checksum
+}

pkg/packet.lua.d/properties.go

@@ -0,0 +1,25 @@
+package packet
+
+func (pkg PacketLua) IsValid() bool {
+
+	var a, b int
+
+	for _, v := range *pkg.Plataforms {
+		a += len(*v.Sources)
+		b += len(v.Architetures)
+	}
+
+	a += len(*pkg.GlobalSources)
+
+	if a < 1 || len(*pkg.Plataforms) > b {
+		return false
+	}
+
+	switch {
+	case pkg.Serial == -133:
+		return false
+	case pkg.Description == "" || pkg.Maintaner == "" || pkg.Name == "" || pkg.Version == "":
+		return false
+	}
+	return true
+}

pkg/packet.lua.d/rand.go

@@ -0,0 +1,13 @@
+package packet
+
+import "math/rand"
+
+const letterBytes = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$%!@%&*()-=+[]{}:;.,1234567890"
+
+func randStringBytes(n int) string {
+	b := make([]byte, n)
+	for i := range b {
+		b[i] = letterBytes[rand.Intn(len(letterBytes))]
+	}
+	return string(b)
+}

test/bat/Packet.lua

@@ -0,0 +1,53 @@
+return {
+    package = {
+        name = "bat-bin", -- required
+        version = "0.26.0", -- required
+        maintainer = "robogg133", -- required
+        description = "A cat(1) clone with syntax highlighting and Git integration.", -- required
+        serial = 0,-- required
+
+        plataforms = {
+            windows = {
+                arch = {"amd64"},
+                sources = {
+                    {
+                        url = "https://github.com/sharkdp/bat/releases/download/v0.26.0/bat-v0.26.0-" ..CURRENT_ARCH_NORMALIZED.."-pc-windows-msvc.zip",
+                        method = "GET",
+                        sha256="a8a6862f14698b45e101b0932c69bc47a007f4c0456f3a129fdcef54d443d501"
+                    }
+                },
+                dependencies = {
+                    build = {},
+                    runtime = {},
+                    conflicts = {}
+                }
+            },
+            linux = {
+                arch = {"amd64"},
+                sources = {
+                    {
+                        url = "https://github.com/sharkdp/bat/releases/download/v0.26.0/bat-v0.26.0-".. CURRENT_ARCH_NORMALIZED .."-unknown-linux-gnu.tar.gz",
+                        method = "GET",
+                        sha256 = "7efed0c768fae36f18ddbbb4a38f5c4b64db7c55a170dfc89fd380805809a44b"
+                    }
+                },
+                dependencies = {
+                    build = {},
+                    runtime = {},
+                    conflicts = {}
+                }
+            }
+        },
+
+        sources = {}
+
+    },
+        
+    build = function() 
+    end,
+    
+    install = function() -- required 
+    print("oi amores")
+    end,
+
+}

test/utctimerightnow/Packet.lua

@@ -0,0 +1,34 @@
+return {
+    package = {
+        name = "utctimerightnow", -- required
+        version = "0.1.0", -- required
+        maintainer = "robogg133", -- required
+        description = "shows utc time", -- required
+        serial = 0,-- required
+
+        dependencies = {
+            build = {"go"},
+            runtime = {},
+            conflicts = {}
+        },
+
+        sources = { --optional 
+            { 
+                url = "https://git.opentty.xyz/robogg133/utctimerightnow.git", -- required
+                method = "git", -- required
+                branch = "main" -- required 
+            --  tag = ""
+            }
+        }
+
+    },
+        
+    build = function()
+
+    end,
+    
+    install  = function() -- required 
+        print("goku")
+    end,
+
+}