feat: Implement plugin availability checks for pre-built binaries and bulk availability

Author: raf181

app/plugins/plugin_installer.go

@@ -1801,52 +1801,99 @@ func extractPluginIDFromRepo(repo string) string {
 // Pre-built Binary Installation
 // =============================================================================
 
-// getPlatformString returns the platform identifier for the current system
-func getPlatformString() string {
-	goos := runtime.GOOS
-	goarch := runtime.GOARCH
+// PluginAvailability represents the available installation options for a plugin
+type PluginAvailability struct {
+	PluginID       string `json:"pluginId"`
+	Repository     string `json:"repository"`
+	Platform       string `json:"platform"`
+	HasStable      bool   `json:"hasStable"`
+	StableVersion  string `json:"stableVersion,omitempty"`
+	StableSize     int64  `json:"stableSize,omitempty"`
+	HasBeta        bool   `json:"hasBeta"`
+	BetaVersion    string `json:"betaVersion,omitempty"`
+	BetaSize       int64  `json:"betaSize,omitempty"`
+	CanBuildSource bool   `json:"canBuildSource"`
+	Error          string `json:"error,omitempty"`
+}
 
-	if goos != "linux" {
-		return "" // Only Linux pre-built binaries are available
+// CheckPluginAvailability checks what installation options are available for a plugin
+func (pi *PluginInstaller) CheckPluginAvailability(org, repo string) PluginAvailability {
+	pluginID := repo
+	if strings.HasPrefix(repo, "Plugin_") {
+		pluginID = strings.TrimPrefix(repo, "Plugin_")
 	}
 
-	switch goarch {
-	case "amd64":
-		return "linux-amd64"
-	case "386":
-		return "linux-386"
-	case "arm64":
-		return "linux-arm64"
-	case "arm":
-		// Detect ARM version - default to ARM6 for compatibility
-		return "linux-arm6"
-	default:
-		return ""
+	platform := getPlatformString()
+	result := PluginAvailability{
+		PluginID:       pluginID,
+		Repository:     fmt.Sprintf("https://github.com/%s/%s", org, repo),
+		Platform:       platform,
+		CanBuildSource: true, // Always available as fallback
 	}
-}
 
-// GitHubRelease represents a GitHub release from the API
-type GitHubRelease struct {
-	TagName    string               `json:"tag_name"`
-	Name       string               `json:"name"`
-	Prerelease bool                 `json:"prerelease"`
-	Assets     []GitHubReleaseAsset `json:"assets"`
-}
+	if platform == "" {
+		result.Error = fmt.Sprintf("No pre-built binaries for %s/%s, source install only", runtime.GOOS, runtime.GOARCH)
+		return result
+	}
 
-// GitHubReleaseAsset represents an asset in a GitHub release
-type GitHubReleaseAsset struct {
-	Name               string `json:"name"`
-	BrowserDownloadURL string `json:"browser_download_url"`
-	Size               int64  `json:"size"`
+	// Check stable release
+	stableRelease, stableAsset, err := pi.findReleaseAsset(org, repo, pluginID, platform, false)
+	if err == nil && stableAsset != nil {
+		result.HasStable = true
+		result.StableVersion = stableRelease.TagName
+		result.StableSize = stableAsset.Size
+	}
+
+	// Check beta release
+	betaRelease, betaAsset, err := pi.findReleaseAsset(org, repo, pluginID, platform, true)
+	if err == nil && betaAsset != nil {
+		result.HasBeta = true
+		result.BetaVersion = betaRelease.TagName
+		result.BetaSize = betaAsset.Size
+	}
+
+	return result
 }
 
-// downloadPrebuiltBinary downloads and installs a pre-built plugin binary from GitHub releases
-func (pi *PluginInstaller) downloadPrebuiltBinary(org, repo, pluginID string, useBeta bool) error {
-	platform := getPlatformString()
-	if platform == "" {
-		return fmt.Errorf("no pre-built binary available for this platform: %s/%s", runtime.GOOS, runtime.GOARCH)
+// CheckMultiplePluginsAvailability checks availability for multiple plugins
+func (pi *PluginInstaller) CheckMultiplePluginsAvailability(repositories []string) []PluginAvailability {
+	results := make([]PluginAvailability, 0, len(repositories))
+
+	for _, repo := range repositories {
+		// Extract org and repo name from the URL
+		parts := strings.Split(repo, "/")
+		var org, repoName string
+		for i, part := range parts {
+			if part == "github.com" && i+2 < len(parts) {
+				org = parts[i+1]
+				repoName = parts[i+2]
+				break
+			}
+		}
+
+		if org == "" || repoName == "" {
+			// Fallback: use last two parts
+			if len(parts) >= 2 {
+				org = parts[len(parts)-2]
+				repoName = parts[len(parts)-1]
+			}
+		}
+
+		// Remove .git suffix if present
+		if strings.HasSuffix(repoName, ".git") {
+			repoName = repoName[:len(repoName)-4]
+		}
+
+		if org != "" && repoName != "" {
+			results = append(results, pi.CheckPluginAvailability(org, repoName))
+		}
 	}
 
+	return results
+}
+
+// findReleaseAsset finds the appropriate asset for the platform in a release
+func (pi *PluginInstaller) findReleaseAsset(org, repo, pluginID, platform string, useBeta bool) (*GitHubRelease, *GitHubReleaseAsset, error) {
 	// Determine which release to fetch
 	var releaseURL string
 	if useBeta {
@@ -1858,7 +1905,7 @@ func (pi *PluginInstaller) downloadPrebuiltBinary(org, repo, pluginID string, us
 	// Create request
 	req, err := http.NewRequest("GET", releaseURL, nil)
 	if err != nil {
-		return fmt.Errorf("failed to create request: %v", err)
+		return nil, nil, fmt.Errorf("failed to create request: %v", err)
 	}
 
 	// Add authentication if available
@@ -1873,51 +1920,95 @@ func (pi *PluginInstaller) downloadPrebuiltBinary(org, repo, pluginID string, us
 	client := &http.Client{Timeout: 30 * time.Second}
 	resp, err := client.Do(req)
 	if err != nil {
-		return fmt.Errorf("failed to fetch release info: %v", err)
+		return nil, nil, fmt.Errorf("failed to fetch release info: %v", err)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("release not found (HTTP %d)", resp.StatusCode)
+		return nil, nil, fmt.Errorf("release not found (HTTP %d)", resp.StatusCode)
 	}
 
 	// Parse release
 	var release GitHubRelease
 	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
-		return fmt.Errorf("failed to parse release info: %v", err)
+		return nil, nil, fmt.Errorf("failed to parse release info: %v", err)
 	}
 
 	// Find the appropriate asset for this platform
-	var assetURL string
-	var assetName string
-	versionSuffix := release.TagName
-	if useBeta {
-		versionSuffix = "beta"
+	for i, asset := range release.Assets {
+		// Try various naming patterns
+		if strings.Contains(asset.Name, platform) && strings.HasSuffix(asset.Name, ".tar.gz") {
+			return &release, &release.Assets[i], nil
+		}
 	}
 
-	expectedName := fmt.Sprintf("%s-%s-%s.tar.gz", pluginID, platform, versionSuffix)
+	return &release, nil, fmt.Errorf("no asset found for platform %s", platform)
+}
 
-	for _, asset := range release.Assets {
-		if asset.Name == expectedName {
-			assetURL = asset.BrowserDownloadURL
-			assetName = asset.Name
-			break
-		}
-		// Also try without version suffix for beta
-		if useBeta && strings.Contains(asset.Name, platform) && strings.HasSuffix(asset.Name, ".tar.gz") {
-			assetURL = asset.BrowserDownloadURL
-			assetName = asset.Name
-		}
+// GetPlatformString exports the platform string for API use
+func GetPlatformString() string {
+	return getPlatformString()
+}
+
+// getPlatformString returns the platform identifier for the current system
+func getPlatformString() string {
+	goos := runtime.GOOS
+	goarch := runtime.GOARCH
+
+	if goos != "linux" {
+		return "" // Only Linux pre-built binaries are available
 	}
 
-	if assetURL == "" {
+	switch goarch {
+	case "amd64":
+		return "linux-amd64"
+	case "386":
+		return "linux-386"
+	case "arm64":
+		return "linux-arm64"
+	case "arm":
+		// Detect ARM version - default to ARM6 for compatibility
+		return "linux-arm6"
+	default:
+		return ""
+	}
+}
+
+// GitHubRelease represents a GitHub release from the API
+type GitHubRelease struct {
+	TagName    string               `json:"tag_name"`
+	Name       string               `json:"name"`
+	Prerelease bool                 `json:"prerelease"`
+	Assets     []GitHubReleaseAsset `json:"assets"`
+}
+
+// GitHubReleaseAsset represents an asset in a GitHub release
+type GitHubReleaseAsset struct {
+	Name               string `json:"name"`
+	BrowserDownloadURL string `json:"browser_download_url"`
+	Size               int64  `json:"size"`
+}
+
+// downloadPrebuiltBinary downloads and installs a pre-built plugin binary from GitHub releases
+func (pi *PluginInstaller) downloadPrebuiltBinary(org, repo, pluginID string, useBeta bool) error {
+	platform := getPlatformString()
+	if platform == "" {
+		return fmt.Errorf("no pre-built binary available for this platform: %s/%s", runtime.GOOS, runtime.GOARCH)
+	}
+
+	// Use the new findReleaseAsset function
+	release, asset, err := pi.findReleaseAsset(org, repo, pluginID, platform, useBeta)
+	if err != nil {
+		return err
+	}
+	if asset == nil {
 		return fmt.Errorf("no binary found for platform %s in release %s", platform, release.TagName)
 	}
 
-	log.Printf("Downloading pre-built binary: %s", assetName)
+	log.Printf("Downloading pre-built binary: %s", asset.Name)
 
 	// Download the asset
-	assetResp, err := http.Get(assetURL)
+	assetResp, err := http.Get(asset.BrowserDownloadURL)
 	if err != nil {
 		return fmt.Errorf("failed to download binary: %v", err)
 	}

frontend/src/api/index.js

@@ -124,6 +124,12 @@ export const pluginManagerApi = {
   // Refresh plugin catalog from GitHub
   refreshCatalog: () => api.post('/plugins/manage/refresh-catalog'),
 
+  // Check if prebuilt binaries are available for a plugin
+  checkAvailability: (repository) => api.post('/plugins/manage/check-availability', { repository }),
+  
+  // Check availability for multiple plugins
+  checkAvailabilityBulk: (repositories) => api.post('/plugins/manage/check-availability-bulk', { repositories }),
+  
   // Install plugin from repository with channel selection
   // channel: 'stable' (default), 'beta', or 'source'
   install: (repository, channel = 'stable') => api.post('/plugins/manage/install', { repository, channel }),