refactor: unified path handle for windows and unix like system

Author: fatelei

pkg/plugin_packager/decoder/fs.go

@@ -126,11 +126,13 @@ func (d *FSPluginDecoder) Close() error {
 }
 
 func (d *FSPluginDecoder) Stat(filename string) (fs.FileInfo, error) {
-	return os.Stat(filepath.Join(d.root, filename))
+	// Convert logical forward-slash paths to OS-native separators at the boundary.
+	return os.Stat(filepath.Join(d.root, filepath.FromSlash(filename)))
 }
 
 func (d *FSPluginDecoder) ReadFile(filename string) ([]byte, error) {
-	return os.ReadFile(filepath.Join(d.root, filename))
+	// Convert logical forward-slash paths to OS-native separators at the boundary.
+	return os.ReadFile(filepath.Join(d.root, filepath.FromSlash(filename)))
 }
 
 func (d *FSPluginDecoder) ReadDir(dirname string) ([]string, error) {
@@ -158,7 +160,8 @@ func (d *FSPluginDecoder) ReadDir(dirname string) ([]string, error) {
 }
 
 func (d *FSPluginDecoder) FileReader(filename string) (io.ReadCloser, error) {
-	return os.Open(filepath.Join(d.root, filename))
+	// Convert logical forward-slash paths to OS-native separators at the boundary.
+	return os.Open(filepath.Join(d.root, filepath.FromSlash(filename)))
 }
 
 func (d *FSPluginDecoder) Signature() (string, error) {

pkg/plugin_packager/decoder/helper.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"path"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -38,7 +39,8 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 	// try to load plugins
 	plugins := dec.Plugins
 	for _, tool := range plugins.Tools {
-		// read yaml
+		// read YAML
+tool = normalizeLogicalPath(tool)
 		pluginYaml, err := decoder.ReadFile(tool)
 		if err != nil {
 			return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read tool file: %s", tool))
@@ -50,15 +52,16 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 		}
 
 		// read tools
-		for _, tool_file := range pluginDec.ToolFiles {
-			toolFileContent, err := decoder.ReadFile(tool_file)
+		for _, toolFile := range pluginDec.ToolFiles {
+toolFile = normalizeLogicalPath(toolFile)
+			toolFileContent, err := decoder.ReadFile(toolFile)
 			if err != nil {
-				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read tool file: %s", tool_file))
+				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read tool file: %s", toolFile))
 			}
 
 			toolFileDec, err := parser.UnmarshalYamlBytes[plugin_entities.ToolDeclaration](toolFileContent)
 			if err != nil {
-				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to unmarshal tool file: %s", tool_file))
+				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to unmarshal tool file: %s", toolFile))
 			}
 
 			pluginDec.Tools = append(pluginDec.Tools, toolFileDec)
@@ -69,6 +72,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 	for _, endpoint := range plugins.Endpoints {
 		// read yaml
+endpoint = normalizeLogicalPath(endpoint)
 		pluginYaml, err := decoder.ReadFile(endpoint)
 		if err != nil {
 			return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read endpoint file: %s", endpoint))
@@ -82,15 +86,16 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 		// read detailed endpoints
 		endpointsFiles := pluginDec.EndpointFiles
 
-		for _, endpoint_file := range endpointsFiles {
-			endpointFileContent, err := decoder.ReadFile(endpoint_file)
+		for _, endpointFile := range endpointsFiles {
+endpointFile = normalizeLogicalPath(endpointFile)
+			endpointFileContent, err := decoder.ReadFile(endpointFile)
 			if err != nil {
-				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read endpoint file: %s", endpoint_file))
+				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read endpoint file: %s", endpointFile))
 			}
 
 			endpointFileDec, err := parser.UnmarshalYamlBytes[plugin_entities.EndpointDeclaration](endpointFileContent)
 			if err != nil {
-				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to unmarshal endpoint file: %s", endpoint_file))
+				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to unmarshal endpoint file: %s", endpointFile))
 			}
 
 			pluginDec.Endpoints = append(pluginDec.Endpoints, endpointFileDec)
@@ -101,6 +106,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 	for _, model := range plugins.Models {
 		// read yaml
+model = normalizeLogicalPath(model)
 		pluginYaml, err := decoder.ReadFile(model)
 		if err != nil {
 			return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read model file: %s", model))
@@ -117,6 +123,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 			llmFileName, ok := pluginDec.PositionFiles["llm"]
 			if ok {
+llmFileName = normalizeLogicalPath(llmFileName)
 				llmFile, err := decoder.ReadFile(llmFileName)
 				if err != nil {
 					return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read llm position file: %s", llmFileName))
@@ -132,6 +139,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 			textEmbeddingFileName, ok := pluginDec.PositionFiles["text_embedding"]
 			if ok {
+textEmbeddingFileName = normalizeLogicalPath(textEmbeddingFileName)
 				textEmbeddingFile, err := decoder.ReadFile(textEmbeddingFileName)
 				if err != nil {
 					return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read text embedding position file: %s", textEmbeddingFileName))
@@ -147,6 +155,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 			rerankFileName, ok := pluginDec.PositionFiles["rerank"]
 			if ok {
+rerankFileName = normalizeLogicalPath(rerankFileName)
 				rerankFile, err := decoder.ReadFile(rerankFileName)
 				if err != nil {
 					return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read rerank position file: %s", rerankFileName))
@@ -162,6 +171,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 			ttsFileName, ok := pluginDec.PositionFiles["tts"]
 			if ok {
+ttsFileName = normalizeLogicalPath(ttsFileName)
 				ttsFile, err := decoder.ReadFile(ttsFileName)
 				if err != nil {
 					return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read tts position file: %s", ttsFileName))
@@ -177,6 +187,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 			speech2textFileName, ok := pluginDec.PositionFiles["speech2text"]
 			if ok {
+speech2textFileName = normalizeLogicalPath(speech2textFileName)
 				speech2textFile, err := decoder.ReadFile(speech2textFileName)
 				if err != nil {
 					return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read speech2text position file: %s", speech2textFileName))
@@ -192,6 +203,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 			moderationFileName, ok := pluginDec.PositionFiles["moderation"]
 			if ok {
+moderationFileName = normalizeLogicalPath(moderationFileName)
 				moderationFile, err := decoder.ReadFile(moderationFileName)
 				if err != nil {
 					return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read moderation position file: %s", moderationFileName))
@@ -208,21 +220,22 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 		// read models
 		if err := decoder.Walk(func(filename, dir string) error {
-			modelPatterns := pluginDec.ModelFiles
-			// using glob to match if dir/filename is in models
-			modelFileName := filepath.Join(dir, filename)
-			if strings.HasSuffix(modelFileName, "_position.yaml") {
+			// Normalize walked relative path to forward slashes so matching is OS-independent
+rel := normalizeLogicalPath(filepath.ToSlash(filepath.Join(dir, filename)))
+			if strings.HasSuffix(rel, "_position.yaml") {
 				return nil
 			}
 
-			for _, model_pattern := range modelPatterns {
-				matched, err := filepath.Match(model_pattern, modelFileName)
+			// Normalize patterns to forward slashes and use POSIX-style matching
+			for _, modelPattern := range pluginDec.ModelFiles {
+pat := normalizeLogicalPath(modelPattern)
+				matched, err := path.Match(pat, rel)
 				if err != nil {
 					return err
 				}
 				if matched {
-					// read model file
-					modelFile, err := decoder.ReadFile(modelFileName)
+					// Read using forward-slash path so both zip and fs decoders work
+					modelFile, err := decoder.ReadFile(rel)
 					if err != nil {
 						return err
 					}
@@ -233,6 +246,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 					}
 
 					pluginDec.Models = append(pluginDec.Models, modelDec)
+					break
 				}
 			}
 
@@ -246,6 +260,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 	for _, agentStrategy := range plugins.AgentStrategies {
 		// read yaml
+agentStrategy = normalizeLogicalPath(agentStrategy)
 		pluginYaml, err := decoder.ReadFile(agentStrategy)
 		if err != nil {
 			return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read agent strategy file: %s", agentStrategy))
@@ -257,6 +272,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 		}
 
 		for _, strategyFile := range pluginDec.StrategyFiles {
+strategyFile = normalizeLogicalPath(strategyFile)
 			strategyFileContent, err := decoder.ReadFile(strategyFile)
 			if err != nil {
 				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read agent strategy file: %s", strategyFile))
@@ -275,6 +291,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 	for _, datasource := range plugins.Datasources {
 		// read yaml
+datasource = normalizeLogicalPath(datasource)
 		pluginYaml, err := decoder.ReadFile(datasource)
 		if err != nil {
 			return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read datasource file: %s", datasource))
@@ -286,6 +303,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 		}
 
 		for _, datasourceFile := range pluginDec.DatasourceFiles {
+datasourceFile = normalizeLogicalPath(datasourceFile)
 			datasourceFileContent, err := decoder.ReadFile(datasourceFile)
 			if err != nil {
 				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read datasource file: %s", datasourceFile))
@@ -304,6 +322,7 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 
 	for _, trigger := range plugins.Triggers {
 		// read yaml
+trigger = normalizeLogicalPath(trigger)
 		pluginYaml, err := decoder.ReadFile(trigger)
 		if err != nil {
 			return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read trigger file: %s", trigger))
@@ -315,15 +334,16 @@ func (p *PluginDecoderHelper) Manifest(decoder PluginDecoder) (plugin_entities.P
 		}
 
 		// read events
-		for _, event_file := range pluginDec.EventFiles {
-			eventFileContent, err := decoder.ReadFile(event_file)
+		for _, eventFile := range pluginDec.EventFiles {
+eventFile = normalizeLogicalPath(eventFile)
+			eventFileContent, err := decoder.ReadFile(eventFile)
 			if err != nil {
-				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read event file: %s", event_file))
+				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to read event file: %s", eventFile))
 			}
 
 			eventFileDec, err := parser.UnmarshalYamlBytes[plugin_entities.EventDeclaration](eventFileContent)
 			if err != nil {
-				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to unmarshal event file: %s", event_file))
+				return plugin_entities.PluginDeclaration{}, errors.Join(err, fmt.Errorf("failed to unmarshal event file: %s", eventFile))
 			}
 
 			pluginDec.Events = append(pluginDec.Events, eventFileDec)

pkg/plugin_packager/decoder/helper_fs_fromslash_test.go

@@ -0,0 +1,34 @@
+package decoder
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestFSDecoder_FromSlashBoundary(t *testing.T) {
+	root := t.TempDir()
+	// Create nested file using OS-native separators
+	p := filepath.Join(root, "dir", "sub", "file.txt")
+	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil { t.Fatal(err) }
+	if err := os.WriteFile(p, []byte("ok"), 0o644); err != nil { t.Fatal(err) }
+
+	dec := &FSPluginDecoder{root: root}
+	if err := dec.Open(); err != nil { t.Fatalf("init open: %v", err) }
+
+	// Use forward-slash logical path; decoder should convert via FromSlash at boundary
+	b, err := dec.ReadFile("dir/sub/file.txt")
+	if err != nil { t.Fatalf("ReadFile with forward slashes: %v", err) }
+	if string(b) != "ok" { t.Fatalf("unexpected content: %q", string(b)) }
+
+	// Stat also accepts forward slashes
+	if _, err := dec.Stat("dir/sub/file.txt"); err != nil { t.Fatalf("Stat with forward slashes: %v", err) }
+
+	// FileReader also accepts forward slashes
+	r, err := dec.FileReader("dir/sub/file.txt")
+	if err != nil { t.Fatalf("FileReader with forward slashes: %v", err) }
+	defer r.Close()
+	data, _ := io.ReadAll(r)
+	if string(data) != "ok" { t.Fatalf("unexpected reader content: %q", string(data)) }
+}