feat: better plugin manager

src/api.go

@@ -275,6 +275,7 @@ func RegisterPluginAPIs(authRouter *auth.RouterDef) {
 	authRouter.HandleFunc("/api/plugins/groups/deleteTag", pluginManager.HandleRemovePluginGroup)
 
 	authRouter.HandleFunc("/api/plugins/store/list", pluginManager.HandleListDownloadablePlugins)
+	authRouter.HandleFunc("/api/plugins/store/urls", pluginManager.HandlePluginStoreURLs)
 	authRouter.HandleFunc("/api/plugins/store/resync", pluginManager.HandleResyncPluginList)
 	authRouter.HandleFunc("/api/plugins/store/install", pluginManager.HandleInstallPlugin)
 	authRouter.HandleFunc("/api/plugins/store/uninstall", pluginManager.HandleUninstallPlugin)

src/mod/plugins/introspect.go

@@ -54,7 +54,13 @@ func (m *Manager) GetPluginSpec(entryPoint string) (*zoraxyPlugin.IntroSpect, er
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	cmd := exec.CommandContext(ctx, entryPoint, "-introspect")
+	absoluteEntryPoint, err := filepath.Abs(entryPoint)
+	if err != nil {
+		return nil, err
+	}
+
+	cmd := exec.CommandContext(ctx, absoluteEntryPoint, "-introspect")
+	cmd.Dir = filepath.Dir(absoluteEntryPoint)
 	output, err := cmd.Output()
 	if ctx.Err() == context.DeadlineExceeded {
 		return nil, fmt.Errorf("plugin introspect timed out")

src/mod/plugins/lifecycle.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
@@ -43,6 +44,12 @@ func (m *Manager) StartPlugin(pluginID string) error {
 		Port:         getRandomPortNumber(),
 		RuntimeConst: *m.Options.SystemConst,
 	}
+	if strings.TrimSpace(m.Options.PluginDataDir) != "" {
+		pluginConfiguration.DataDir = filepath.Join(m.Options.PluginDataDir, thisPlugin.Spec.ID)
+		if err := os.MkdirAll(pluginConfiguration.DataDir, 0o775); err != nil {
+			return err
+		}
+	}
 
 	// Generate API key if the plugin has permitted endpoints
 	if len(thisPlugin.Spec.PermittedAPIEndpoints) > 0 {

src/mod/plugins/store.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	urlpkg "net/url"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -23,26 +24,103 @@ import (
 
 // See https://github.com/aroz-online/zoraxy-official-plugins/blob/main/directories/index2.json for the standard format
 
+var defaultPluginStoreURLs = []string{
+	"https://raw.githubusercontent.com/aroz-online/zoraxy-official-plugins/refs/heads/main/directories/index2.json",
+}
+
 type DownloadablePlugin struct {
 	IconPath         string                   `json:"IconPath"`         //Icon path or URL for the plugin
 	PluginIntroSpect zoraxy_plugin.IntroSpect `json:"PluginIntroSpect"` //Plugin introspect information
 	DownloadURLs     map[string]string        `json:"DownloadURLs"`     //Download URLs for different platforms
 }
 
+func GetDefaultPluginStoreURLs() []string {
+	return append([]string{}, defaultPluginStoreURLs...)
+}
+
+func normalizePluginStoreURLs(rawURLs []string) []string {
+	seen := map[string]bool{}
+	normalized := []string{}
+	for _, rawURL := range rawURLs {
+		trimmed := strings.TrimSpace(rawURL)
+		if trimmed == "" || seen[trimmed] {
+			continue
+		}
+		seen[trimmed] = true
+		normalized = append(normalized, trimmed)
+	}
+	if len(normalized) == 0 {
+		return GetDefaultPluginStoreURLs()
+	}
+	return normalized
+}
+
+func (m *Manager) GetPluginStoreURLs() []string {
+	return normalizePluginStoreURLs(m.Options.PluginStoreURLs)
+}
+
+func (m *Manager) LoadPluginStoreURLs() error {
+	if m.Options.Database == nil {
+		m.Options.PluginStoreURLs = normalizePluginStoreURLs(m.Options.PluginStoreURLs)
+		return nil
+	}
+
+	loaded := []string{}
+	if err := m.Options.Database.Read("plugins", "store_urls", &loaded); err != nil {
+		m.Options.PluginStoreURLs = normalizePluginStoreURLs(m.Options.PluginStoreURLs)
+		return nil
+	}
+
+	m.Options.PluginStoreURLs = normalizePluginStoreURLs(loaded)
+	return nil
+}
+
+func (m *Manager) SavePluginStoreURLs(urls []string) error {
+	normalized := normalizePluginStoreURLs(urls)
+	m.Options.PluginStoreURLs = normalized
+	if m.Options.Database == nil {
+		return nil
+	}
+	return m.Options.Database.Write("plugins", "store_urls", normalized)
+}
+
 /* Plugin Store Index List Sync */
 //Update the plugin list from the plugin store URLs
 func (m *Manager) UpdateDownloadablePluginList() error {
 	//Get downloadable plugins from each of the plugin store URLS
-	m.Options.DownloadablePluginCache = []*DownloadablePlugin{}
-	for _, url := range m.Options.PluginStoreURLs {
-		pluginList, err := m.getPluginListFromURL(url)
+	m.Options.PluginStoreURLs = normalizePluginStoreURLs(m.Options.PluginStoreURLs)
+	combined := []*DownloadablePlugin{}
+	seenPluginIDs := map[string]bool{}
+	errors := []string{}
+	successfulSources := 0
+	for _, sourceURL := range m.Options.PluginStoreURLs {
+		pluginList, err := m.getPluginListFromURL(sourceURL)
 		if err != nil {
-			return fmt.Errorf("failed to get plugin list from %s: %w", url, err)
+			errors = append(errors, fmt.Sprintf("%s: %s", sourceURL, err.Error()))
+			continue
+		}
+		successfulSources++
+		for _, plugin := range pluginList {
+			if plugin == nil || plugin.PluginIntroSpect.ID == "" {
+				continue
+			}
+			if seenPluginIDs[plugin.PluginIntroSpect.ID] {
+				continue
+			}
+			seenPluginIDs[plugin.PluginIntroSpect.ID] = true
+			combined = append(combined, plugin)
 		}
-		m.Options.DownloadablePluginCache = append(m.Options.DownloadablePluginCache, pluginList...)
 	}
 
-	m.Options.LastSuccPluginSyncTime = time.Now().Unix()
+	m.Options.DownloadablePluginCache = combined
+
+	if successfulSources > 0 {
+		m.Options.LastSuccPluginSyncTime = time.Now().Unix()
+	}
+
+	if successfulSources == 0 && len(errors) > 0 {
+		return fmt.Errorf("failed to sync any plugin repository: %s", strings.Join(errors, "; "))
+	}
 
 	return nil
 }
@@ -72,16 +150,42 @@ func (m *Manager) getPluginListFromURL(url string) ([]*DownloadablePlugin, error
 		return nil, fmt.Errorf("failed to unmarshal plugin list from %s: %w", url, err)
 	}
 
+	baseURL, _ := urlpkg.Parse(url)
+
 	// Filter out if IconPath is empty string, set it to "/img/plugin_icon.png"
 	for _, plugin := range pluginList {
 		if strings.TrimSpace(plugin.IconPath) == "" {
 			plugin.IconPath = "/img/plugin_icon.png"
+		} else if resolvedURL := resolvePluginStoreAssetURL(baseURL, plugin.IconPath); resolvedURL != "" {
+			plugin.IconPath = resolvedURL
+		}
+
+		for platform, downloadURL := range plugin.DownloadURLs {
+			if resolvedURL := resolvePluginStoreAssetURL(baseURL, downloadURL); resolvedURL != "" {
+				plugin.DownloadURLs[platform] = resolvedURL
+			}
 		}
 	}
 
 	return pluginList, nil
 }
 
+func resolvePluginStoreAssetURL(baseURL *urlpkg.URL, raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+
+	parsed, err := urlpkg.Parse(raw)
+	if err != nil {
+		return raw
+	}
+	if parsed.IsAbs() || baseURL == nil {
+		return raw
+	}
+	return baseURL.ResolveReference(parsed).String()
+}
+
 func (m *Manager) ListDownloadablePlugins() []*DownloadablePlugin {
 	//List all downloadable plugins
 	if len(m.Options.DownloadablePluginCache) == 0 {
@@ -217,6 +321,43 @@ func (m *Manager) HandleListDownloadablePlugins(w http.ResponseWriter, r *http.R
 	utils.SendJSONResponse(w, string(js))
 }
 
+func (m *Manager) HandlePluginStoreURLs(w http.ResponseWriter, r *http.Request) {
+	switch r.Method {
+	case http.MethodGet:
+		payload := map[string]any{
+			"urls":               m.GetPluginStoreURLs(),
+			"default_urls":       GetDefaultPluginStoreURLs(),
+			"last_sync_unix":     m.Options.LastSuccPluginSyncTime,
+			"repository_count":   len(m.GetPluginStoreURLs()),
+			"downloadable_count": len(m.Options.DownloadablePluginCache),
+		}
+		js, _ := json.Marshal(payload)
+		utils.SendJSONResponse(w, string(js))
+	case http.MethodPost:
+		rawURLs, err := utils.PostPara(r, "urls")
+		if err != nil && !strings.Contains(err.Error(), "invalid urls") {
+			utils.SendErrorResponse(w, "urls not found")
+			return
+		}
+		urls := []string{}
+		if strings.TrimSpace(rawURLs) != "" {
+			for _, line := range strings.Split(rawURLs, "\n") {
+				line = strings.TrimSpace(line)
+				if line != "" {
+					urls = append(urls, line)
+				}
+			}
+		}
+		if err := m.SavePluginStoreURLs(urls); err != nil {
+			utils.SendErrorResponse(w, "failed to save plugin store URLs: "+err.Error())
+			return
+		}
+		utils.SendOK(w)
+	default:
+		utils.SendErrorResponse(w, "Method not allowed")
+	}
+}
+
 // HandleResyncPluginList is the handler for resyncing the plugin list from the plugin store URLs
 func (m *Manager) HandleResyncPluginList(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodPost {

src/mod/plugins/typdef.go

@@ -43,11 +43,12 @@ type ManagerOptions struct {
 	LastSuccPluginSyncTime  int64                 //The last sync time for the plugin store URLs, used to check if the plugin store URLs need to be synced again
 
 	/* Runtime */
-	SystemConst  *zoraxyPlugin.RuntimeConstantValue //The system constant value
-	ZoraxyPort   int                                //The port of the Zoraxy instance, used for API calls
-	CSRFTokenGen func(*http.Request) string         `json:"-"` //The CSRF token generator function
-	Database     *database.Database                 `json:"-"`
-	Logger       *logger.Logger                     `json:"-"`
+	SystemConst   *zoraxyPlugin.RuntimeConstantValue //The system constant value
+	ZoraxyPort    int                                //The port of the Zoraxy instance, used for API calls
+	PluginDataDir string                             //Base directory for plugin persistent data, typically under the Zoraxy conf folder
+	CSRFTokenGen  func(*http.Request) string         `json:"-"` //The CSRF token generator function
+	Database      *database.Database                 `json:"-"`
+	Logger        *logger.Logger                     `json:"-"`
 
 	/* API Key Management */
 	APIKeyManager *auth.APIKeyManager `json:"-"` //The API key manager for the plugins

src/mod/plugins/utils.go

@@ -32,6 +32,25 @@ func (m *Manager) GetPluginEntryPoint(folderpath string) (string, error) {
 	if !info.IsDir() {
 		return "", errors.New("path is not a directory")
 	}
+
+	startScriptPath := filepath.Join(folderpath, "start.sh")
+	startBatchPath := filepath.Join(folderpath, "start.bat")
+	goModPath := filepath.Join(folderpath, "go.mod")
+
+	// Prefer source entrypoints for plugin repositories that ship source code.
+	// This avoids stale checked-in binaries shadowing newer API/UI changes.
+	if _, err := os.Stat(goModPath); err == nil {
+		if runtime.GOOS == "windows" {
+			if _, err := os.Stat(startBatchPath); err == nil {
+				return startBatchPath, nil
+			}
+		} else {
+			if _, err := os.Stat(startScriptPath); err == nil {
+				return startScriptPath, nil
+			}
+		}
+	}
+
 	expectedBinaryPath := filepath.Join(folderpath, filepath.Base(folderpath))
 	if runtime.GOOS == "windows" {
 		expectedBinaryPath += ".exe"
@@ -41,12 +60,12 @@ func (m *Manager) GetPluginEntryPoint(folderpath string) (string, error) {
 		return expectedBinaryPath, nil
 	}
 
-	if _, err := os.Stat(filepath.Join(folderpath, "start.sh")); err == nil {
-		return filepath.Join(folderpath, "start.sh"), nil
+	if _, err := os.Stat(startScriptPath); err == nil {
+		return startScriptPath, nil
 	}
 
-	if _, err := os.Stat(filepath.Join(folderpath, "start.bat")); err == nil {
-		return filepath.Join(folderpath, "start.bat"), nil
+	if _, err := os.Stat(startBatchPath); err == nil {
+		return startBatchPath, nil
 	}
 
 	return "", errors.New("no valid entry point found")

src/mod/plugins/zoraxy_plugin/zoraxy_plugin.go

@@ -139,6 +139,7 @@ type ConfigureSpec struct {
 	RuntimeConst RuntimeConstantValue `json:"runtime_const"`         //Runtime constant values
 	APIKey       string               `json:"api_key,omitempty"`     //API key for accessing Zoraxy APIs, if the plugin has permitted endpoints
 	ZoraxyPort   int                  `json:"zoraxy_port,omitempty"` //The port that Zoraxy is running on, used for making API calls to Zoraxy
+	DataDir      string               `json:"data_dir,omitempty"`    //Directory for plugin-owned persistent data, located under the Zoraxy config folder
 	//To be expanded
 }
 

src/start.go

@@ -374,6 +374,7 @@ func startupSequence() {
 
 	pluginManager = plugins.NewPluginManager(&plugins.ManagerOptions{
 		PluginDir:          pluginFolder,
+		PluginDataDir:      filepath.Join(CONF_FOLDER, "plugins"),
 		Database:           sysdb,
 		Logger:             SystemWideLogger,
 		PluginGroupsConfig: CONF_PLUGIN_GROUPS,
@@ -388,14 +389,14 @@ func startupSequence() {
 			DevelopmentBuild: *development_build,
 		},
 		/* Plugin Store URLs */
-		PluginStoreURLs: []string{
-			"https://raw.githubusercontent.com/aroz-online/zoraxy-official-plugins/refs/heads/main/directories/index2.json",
-			//TO BE ADDED
-		},
+		PluginStoreURLs: plugins.GetDefaultPluginStoreURLs(),
 		/* Developer Options */
 		EnableHotReload:   *development_build, //Default to true if development build
 		HotReloadInterval: 5,                  //seconds
 	})
+	if err := pluginManager.LoadPluginStoreURLs(); err != nil {
+		SystemWideLogger.PrintAndLog("plugin-manager", "Failed to load plugin store URLs; using defaults", err)
+	}
 
 	/*
 		Event Manager