Plugin registry github and Smart contract management (#14)

* Update plugin handling and enhance file input functionality

- Added validation for existing plugins during updates to ensure they exist before proceeding, improving error handling and user feedback.
- Preserved deployment status when updating plugins to maintain consistency in their configurations.
- Introduced a new `FileValue` struct for handling file-based x-source values, including validation and volume mount configurations.
- Enhanced the `DeploymentModal` to support file input, allowing users to upload or paste file contents directly, improving usability.
- Updated Swagger documentation to reflect changes in API endpoints and request structures.

These changes enhance the overall functionality and user experience when managing plugins and file inputs within the application.


* Add metrics management commands and enhance API functionality

- Introduced new commands for enabling and disabling Prometheus metrics, allowing users to manage metrics deployment directly from the CLI.
- Implemented HTTP handlers for the new metrics commands, ensuring proper request handling and response formatting.
- Enhanced the metrics service layer to support the new commands, including validation and error handling for metrics operations.
- Updated Swagger documentation to reflect the new API endpoints and their functionalities, improving usability for developers.

These changes enhance the overall functionality of the application by providing users with better tools for managing metrics and Prometheus integration.


* Update Swagger documentation and enhance response models for metrics API

- Updated Swagger documentation to reflect new response structures for metrics-related endpoints, ensuring accurate descriptions and references.
- Introduced new response models: `MessageResponse`, `LabelValuesResponse`, and `MetricsDataResponse` to standardize API responses across metrics endpoints.
- Enhanced error handling and response formatting in the metrics handler methods to utilize the new structured response models, improving consistency and clarity.

These changes improve the overall usability and maintainability of the metrics API, providing clearer and more structured responses for users.


* Enhance application structure and add smart contract deployment functionality

- Updated `.gitignore` to include logs and environment-specific files, improving project cleanliness.
- Modified `go.mod` and `go.sum` to add new dependencies for smart contract deployment and plugin management, ensuring compatibility with the latest features.
- Implemented a new `chainlaunchdeploy` package for handling smart contract deployments on EVM and Fabric networks, including validation and error handling.
- Introduced HTTP handlers for smart contract deployment requests, enhancing the API with new endpoints for Besu and Fabric deployments.
- Updated Swagger documentation to reflect the new deployment endpoints and their request/response structures, improving API usability.

These changes enhance the overall functionality of the application by providing robust support for smart contract deployments and improving project organization.


* Update


* Refactor Fabric chaincode routes and enhance peer handling

- Updated HTTP routes for Fabric chaincode operations to include peer ID in the URL, improving clarity and specificity in API requests.
- Introduced new stub functions for peer lookup and conversion to gateway, laying the groundwork for future implementation.
- Enhanced error handling in chaincode installation, approval, and commit methods to ensure robust validation and logging for peer-related operations.

These changes improve the overall structure and error management of the Fabric chaincode handling, ensuring better API usability and maintainability.


* Update plugin registry configuration and enhance GitHub source handling

- Changed the plugin registry source name from "github-public-plugins" to "plugin-hlf-api" for better clarity.
- Updated the URL for the GitHub source to point to the correct repository.
- Refined the file filtering logic in the GitHub source to only consider "plugin.yaml" or "plugin.yml" files, improving accuracy in plugin metadata retrieval.
- Enhanced the PluginMetadata structure to include additional fields such as Tags, Author, License, Hash, Rating, Downloads, Created, Updated, and Labels for better plugin information representation.

These changes improve the plugin management functionality and ensure more accurate handling of plugin metadata.


* Update API documentation and enhance plugin management functionality

- Updated Swagger and YAML documentation to reflect changes in Fabric chaincode operations, including new endpoints for deploying and approving chaincode with peer ID in the URL.
- Enhanced the PluginMetadata structure to include a new field for raw YAML, improving the representation of plugin data.
- Introduced new API methods for managing available plugins, including installation and refreshing of plugin lists, enhancing user experience in the plugins page.

These changes improve the overall usability and maintainability of the API and plugin management features, ensuring better clarity and functionality for users.


* Enhance API documentation and introduce new tags for improved clarity

- Updated Swagger documentation to include new tags for Audit and Metrics management operations, enhancing the organization and discoverability of API endpoints.
- Modified existing handler methods to reflect the new tag names, ensuring consistency across the codebase.
- Improved the structure of the Fabric chaincode deployment handler to include a node service, facilitating better peer management during operations.

These changes enhance the overall usability and maintainability of the API, providing clearer documentation and improved functionality for users.


* Update it


* Enhance Fabric chaincode deployment functionality and API documentation

- Introduced new endpoints for listing deployed Fabric chaincodes and deploying chaincodes using Docker images, improving the API's capabilities for managing smart contracts.
- Updated the HTTP handler to include a new ChaincodeService for better separation of concerns and improved business logic handling.
- Enhanced Swagger documentation to reflect the new endpoints and their request/response structures, ensuring clarity and usability for developers.
- Implemented database operations for managing Fabric chaincodes, including insertion and updates, to support the new functionalities.

These changes significantly improve the overall functionality and maintainability of the application, providing users with better tools for managing Fabric chaincodes.


* Update Fabric chaincode API documentation and enhance deployment features

- Improved Swagger documentation for Fabric chaincode endpoints, including detailed descriptions and response models for listing and retrieving chaincodes, ensuring clarity for developers.
- Enhanced the API to support new functionalities for managing Fabric chaincodes, including detailed runtime information and Docker deployment options.
- Updated HTTP handlers to reflect changes in the service layer, ensuring better separation of concerns and improved error handling.
- Implemented new database operations for managing chaincode definitions and peer statuses, enhancing the overall functionality of the application.

These updates significantly improve the usability and maintainability of the Fabric chaincode management features, providing users with better tools for deployment and monitoring.


* Enhance ChaincodeService with logging and new functionalities

- Updated ChaincodeService to include a logger for improved debugging and error tracking.
- Modified the NewChaincodeService constructor to accept a logger parameter, ensuring better logging practices.
- Implemented new methods for generating connection packages and handling code tar.gz files, enhancing the deployment process for chaincodes.
- Improved error handling and logging throughout the service methods, ensuring robust operation and easier troubleshooting.

These changes significantly enhance the functionality and maintainability of the ChaincodeService, providing better tools for managing chaincode deployments.


* Refactor Fabric chaincode management and enhance API functionality

- Updated the ChaincodeService to include a nodesService for improved peer management during chaincode operations.
- Modified HTTP handlers to reflect changes in the service layer, ensuring better separation of concerns and improved error handling.
- Enhanced Swagger documentation for Fabric chaincode endpoints, including updated descriptions and response models for better clarity.
- Implemented new database operations for managing chaincode definitions and events, enhancing the overall functionality of the application.

These updates significantly improve the usability and maintainability of the Fabric chaincode management features, providing users with better tools for deployment and monitoring.


* Refactor FabricChaincodesPage to improve query handling and state management

- Removed unused queryClient and replaced it with refetch functions for better control over data fetching.
- Updated the useQuery hooks to include refetch capabilities for networks and chaincodes, enhancing the responsiveness of the component.
- Improved the success handling of chaincode creation to directly refetch chaincodes instead of invalidating queries, streamlining the data update process.

These changes enhance the performance and maintainability of the FabricChaincodesPage, providing a more efficient user experience.


* update


* Refactor DefinitionTimeline component for improved readability and performance

- Simplified the useQuery hook for fetching timeline data by removing unnecessary line breaks.
- Streamlined conditional rendering for result icons and button components to enhance code clarity.
- Utilized useMemo for filtering available peers, optimizing performance during re-renders.
- Consolidated error message rendering for better consistency across the component.

These changes enhance the maintainability and performance of the DefinitionTimeline component, providing a more efficient user experience.


* Update


* Enhance Docker image pull handling in metrics and Besu node management

- Updated the Prometheus and Besu Docker handlers to read and log the image pull response, improving visibility during the image pull process.
- Implemented error handling for the image pull response reading, ensuring robust operation and easier troubleshooting.

These changes enhance the reliability and maintainability of the Docker image management features in the application.


* Refactor log handling in Node HTTP and React components

- Updated the TailLogs handler to format log messages correctly for SSE by adding "data: " prefix.
- Replaced the fetch-based log retrieval in NodeDetailPage and NodesLogsPage with EventSource for real-time log streaming, improving performance and user experience.
- Implemented error handling for EventSource connections and ensured proper cleanup on component unmount.

These changes enhance the log streaming functionality, providing a more efficient and responsive user experience in the application.

Author: dviejokfs

.gitignore

@@ -11,4 +11,31 @@ certs
 test-instance
 *.db
 decode_extradata
-.artifacts
+.artifacts
+.cursor
+
+# Added by Claude Task Master
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+dev-debug.log
+# Dependency directories
+node_modules/
+# Environment variables
+# Editor directories and files
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+# OS specific
+# Task files
+tasks.json
+tasks/ 
+.roo
+.taskmasterconfig
+scripts

cmd/common/client.go

@@ -55,7 +55,6 @@ func (c *Client) DoRequest(method, path string, body interface{}) (*http.Respons
 		}
 		reqBody = bytes.NewBuffer(jsonBody)
 	}
-
 	// Create HTTP request
 	req, err := http.NewRequest(method, fmt.Sprintf("%s%s", c.baseURL, path), reqBody)
 	if err != nil {

cmd/common/metrics.go

@@ -0,0 +1,73 @@
+package common
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+
+	metricscommon "github.com/chainlaunch/chainlaunch/pkg/metrics/common"
+	metricstypes "github.com/chainlaunch/chainlaunch/pkg/metrics/types"
+)
+
+// EnableMetrics deploys Prometheus using the provided parameters
+func (c *Client) EnableMetrics(req *metricscommon.Config) (map[string]string, error) {
+	// Convert common.Config to the HTTP request struct expected by the API
+	httpReq := metricstypes.DeployPrometheusRequest{
+		PrometheusVersion: req.PrometheusVersion,
+		PrometheusPort:    req.PrometheusPort,
+		ScrapeInterval:    int(req.ScrapeInterval.Seconds()),
+	}
+	resp, err := c.Post("/metrics/deploy", httpReq)
+	if err != nil {
+		return nil, fmt.Errorf("failed to call /metrics/deploy: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		var errResp map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&errResp)
+		return nil, fmt.Errorf("unexpected status %d: %v", resp.StatusCode, errResp)
+	}
+	var result map[string]string
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+	return result, nil
+}
+
+// DisableMetrics undeploys Prometheus
+func (c *Client) DisableMetrics() (map[string]string, error) {
+	resp, err := c.Post("/metrics/undeploy", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to call /metrics/undeploy: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		var errResp map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&errResp)
+		return nil, fmt.Errorf("unexpected status %d: %v", resp.StatusCode, errResp)
+	}
+	var result map[string]string
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+	return result, nil
+}
+
+// GetMetricsStatus returns the current status of the Prometheus instance
+func (c *Client) GetMetricsStatus() (*metricscommon.Status, error) {
+	resp, err := c.Get("/metrics/status")
+	if err != nil {
+		return nil, fmt.Errorf("failed to call /metrics/status: %w", err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		var errResp map[string]interface{}
+		json.NewDecoder(resp.Body).Decode(&errResp)
+		return nil, fmt.Errorf("unexpected status %d: %v", resp.StatusCode, errResp)
+	}
+	var status metricscommon.Status
+	if err := json.NewDecoder(resp.Body).Decode(&status); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+	return &status, nil
+}

cmd/metrics/disable.go

@@ -0,0 +1,43 @@
+package metrics
+
+import (
+	"fmt"
+
+	"github.com/chainlaunch/chainlaunch/cmd/common"
+	"github.com/spf13/cobra"
+)
+
+// DisableMetricsRunner encapsulates the logic for disabling metrics
+type DisableMetricsRunner struct{}
+
+func (r *DisableMetricsRunner) Run() error {
+	client, err := common.NewClientFromEnv()
+	if err != nil {
+		return err
+	}
+	status, err := client.GetMetricsStatus()
+	if err != nil {
+		return fmt.Errorf("could not get metrics status: %w", err)
+	}
+	if status.Status != "running" {
+		return fmt.Errorf("Prometheus is not running (status: %s)", status.Status)
+	}
+	resp, err := client.DisableMetrics()
+	if err != nil {
+		return err
+	}
+	fmt.Printf("Prometheus undeployed: %v\n", resp)
+	return nil
+}
+
+func NewDisableCmd() *cobra.Command {
+	runner := &DisableMetricsRunner{}
+	cmd := &cobra.Command{
+		Use:   "disable",
+		Short: "Disable metrics by undeploying Prometheus",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runner.Run()
+		},
+	}
+	return cmd
+}

cmd/metrics/enable.go

@@ -0,0 +1,87 @@
+// Package metrics provides the 'metrics enable' command to deploy Prometheus for metrics collection.
+package metrics
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/chainlaunch/chainlaunch/cmd/common"
+	metricscommon "github.com/chainlaunch/chainlaunch/pkg/metrics/common"
+	"github.com/spf13/cobra"
+)
+
+// EnableMetricsConfig holds the parameters for enabling metrics
+type EnableMetricsConfig struct {
+	PrometheusVersion string
+	PrometheusPort    int
+	ScrapeInterval    int
+}
+
+// EnableMetricsRunner encapsulates the config and logic for running and validating the enable metrics command
+type EnableMetricsRunner struct {
+	Config EnableMetricsConfig
+}
+
+// Validate checks the configuration for required fields
+func (r *EnableMetricsRunner) Validate() error {
+	if r.Config.PrometheusVersion == "" {
+		return fmt.Errorf("--version is required")
+	}
+	if r.Config.PrometheusPort <= 0 {
+		return fmt.Errorf("--port must be greater than 0")
+	}
+	if r.Config.ScrapeInterval <= 0 {
+		return fmt.Errorf("--scrape-interval must be greater than 0")
+	}
+	return nil
+}
+
+// Run executes the enable metrics logic
+func (r *EnableMetricsRunner) Run() error {
+	if err := r.Validate(); err != nil {
+		return err
+	}
+	client, err := common.NewClientFromEnv()
+	if err != nil {
+		return err
+	}
+	status, err := client.GetMetricsStatus()
+	if err == nil && status.Status == "running" {
+		return fmt.Errorf("Prometheus is already deployed (status: running)")
+	}
+	cfg := &metricscommon.Config{
+		PrometheusVersion: r.Config.PrometheusVersion,
+		PrometheusPort:    r.Config.PrometheusPort,
+		ScrapeInterval:    time.Duration(r.Config.ScrapeInterval) * time.Second,
+	}
+	resp, err := client.EnableMetrics(cfg)
+	if err != nil {
+		return err
+	}
+	fmt.Printf("Prometheus deployed: %v\n", resp)
+	return nil
+}
+
+func NewEnableCmd() *cobra.Command {
+	runner := &EnableMetricsRunner{
+		Config: EnableMetricsConfig{
+			PrometheusVersion: "v3.4.0",
+			PrometheusPort:    9090,
+			ScrapeInterval:    15,
+		},
+	}
+
+	cmd := &cobra.Command{
+		Use:   "enable",
+		Short: "Enable metrics by deploying Prometheus",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runner.Run()
+		},
+	}
+
+	cmd.Flags().StringVar(&runner.Config.PrometheusVersion, "version", "v3.3.1", "Prometheus version")
+	cmd.Flags().IntVar(&runner.Config.PrometheusPort, "port", 9090, "Prometheus port")
+	cmd.Flags().IntVar(&runner.Config.ScrapeInterval, "scrape-interval", 15, "Scrape interval in seconds")
+
+	return cmd
+}

cmd/metrics/metrics.go

@@ -0,0 +1,16 @@
+package metrics
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// NewMetricsCmd creates the 'metrics' parent command
+func NewMetricsCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "metrics",
+		Short: "Manage metrics and Prometheus integration",
+	}
+	cmd.AddCommand(NewEnableCmd())
+	cmd.AddCommand(NewDisableCmd())
+	return cmd
+}

cmd/root.go

@@ -8,6 +8,7 @@ import (
 	"github.com/chainlaunch/chainlaunch/cmd/besu"
 	"github.com/chainlaunch/chainlaunch/cmd/fabric"
 	"github.com/chainlaunch/chainlaunch/cmd/keymanagement"
+	"github.com/chainlaunch/chainlaunch/cmd/metrics"
 	"github.com/chainlaunch/chainlaunch/cmd/networks"
 	"github.com/chainlaunch/chainlaunch/cmd/serve"
 	"github.com/chainlaunch/chainlaunch/cmd/testnet"
@@ -37,6 +38,7 @@ func NewRootCmd(configCMD config.ConfigCMD) *cobra.Command {
 	rootCmd.AddCommand(networks.NewNetworksCmd(logger))
 	rootCmd.AddCommand(keymanagement.NewKeyManagementCmd())
 	rootCmd.AddCommand(testnet.NewTestnetCmd())
+	rootCmd.AddCommand(metrics.NewMetricsCmd())
 	// In the function where rootCmd is defined and commands are added:
 	// rootCmd.AddCommand(testnet.NewTestnetCmd())
 	return rootCmd

cmd/serve/serve.go

@@ -33,6 +33,7 @@ import (
 	nodeTypes "github.com/chainlaunch/chainlaunch/pkg/nodes/types"
 
 	"github.com/chainlaunch/chainlaunch/pkg/audit"
+	"github.com/chainlaunch/chainlaunch/pkg/chainlaunchdeploy"
 	"github.com/chainlaunch/chainlaunch/pkg/metrics"
 	networkshttp "github.com/chainlaunch/chainlaunch/pkg/networks/http"
 	networksservice "github.com/chainlaunch/chainlaunch/pkg/networks/service"
@@ -41,6 +42,7 @@ import (
 	notificationhttp "github.com/chainlaunch/chainlaunch/pkg/notifications/http"
 	notificationservice "github.com/chainlaunch/chainlaunch/pkg/notifications/service"
 	"github.com/chainlaunch/chainlaunch/pkg/plugin"
+	pluginregistry "github.com/chainlaunch/chainlaunch/pkg/plugin/registry"
 	settingshttp "github.com/chainlaunch/chainlaunch/pkg/settings/http"
 	settingsservice "github.com/chainlaunch/chainlaunch/pkg/settings/service"
 	"github.com/go-chi/chi/v5"
@@ -137,6 +139,9 @@ func (h spaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // @in cookie
 // @name session_id
 
+// @tag.name Audit
+// @tag.description Audit management operations
+
 // @tag.name Authentication
 // @tag.description User authentication and authorization operations
 
@@ -158,6 +163,9 @@ func (h spaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // @tag.name Keys
 // @tag.description Cryptographic key management operations
 
+// @tag.name Metrics
+// @tag.description Metrics management operations
+
 // @tag.name Nodes
 // @tag.description Network node management operations
 
@@ -176,6 +184,9 @@ func (h spaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // @tag.name Settings
 // @tag.description Settings management operations
 
+// @tag.name SmartContracts
+// @tag.description Smart contract management operations
+
 // @tag.name Users
 // @tag.description User account management operations
 
@@ -425,7 +436,45 @@ func setupServer(queries *db.Queries, authService *auth.AuthService, views embed
 	if err != nil {
 		log.Fatal("Failed to initialize plugin manager:", err)
 	}
-	pluginHandler := plugin.NewHandler(pluginStore, pluginManager, logger)
+	// --- Registry integration for GitHub plugins ---
+	// TODO: Load registry config from file or env
+	regConfig := &pluginregistry.RegistryConfig{
+		Sources: []pluginregistry.RegistrySource{
+			{
+				Name:    "plugin-hlf-api",
+				Type:    "github",
+				URL:     "https://github.com/kfsoftware/plugin-hlf-api", // Example public repo
+				Enabled: true,
+			},
+		},
+	}
+	reg, err := pluginregistry.NewRegistry(regConfig)
+	if err != nil {
+		log.Fatal("Failed to initialize plugin registry:", err)
+	}
+
+	// Create and start available plugins cache
+	availablePluginsCache := pluginregistry.NewAvailablePluginsCache()
+	go func() {
+		for {
+			plugins, err := reg.ListAvailablePluginsFromGitHub()
+			if err == nil {
+				availablePluginsCache.Set(plugins)
+			} else {
+				log.Printf("Failed to refresh available plugins from GitHub: %v", err)
+			}
+			time.Sleep(5 * time.Minute)
+		}
+	}()
+
+	registryStore := plugin.NewRegistryStore(pluginStore, reg)
+	pluginHandler := plugin.NewHandler(registryStore, pluginManager, logger, reg, availablePluginsCache)
+
+	// --- Smart contract deployment handler (Fabric & Besu) ---
+	// Import the EVM deployer constructor
+	besuDeployer := chainlaunchdeploy.NewDeployerWithAudit(auditService)
+	chaincodeService := chainlaunchdeploy.NewChaincodeService(queries, logger, nodesService)
+	scHandler := chainlaunchdeploy.NewHandler(auditService, logger, besuDeployer, nodesService, chaincodeService)
 
 	// Initialize handlers
 	keyManagementHandler := handler.NewKeyManagementHandler(keyManagementService)
@@ -492,6 +541,9 @@ func setupServer(queries *db.Queries, authService *auth.AuthService, views embed
 
 			// Mount audit routes
 			auditHandler.RegisterRoutes(r)
+
+			// Register smart contract deployment routes
+			scHandler.RegisterRoutes(r)
 		})
 	})
 	r.Get("/api/swagger/*", httpSwagger.Handler(