feat(cli): change network commands (#89)

Signed-off-by: Tagscherer Ádám <[email protected]>

Author: adamtagscherer

Diff for: cli/cmd/network/info/info.go

@@ -10,15 +10,12 @@ import (
 	"os"
 
 	"github.com/agntcy/dir/cli/presenter"
-	"github.com/agntcy/dir/utils/logging"
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/spf13/cobra"
 	"golang.org/x/crypto/ssh"
 )
 
-var logger = logging.Logger("cli/network/info")
-
 var Command = &cobra.Command{
 	Use:   "info",
 	Short: "Generates the peer id from a private key, enabling connection to the DHT network",
@@ -47,8 +44,6 @@ Usage examples:
 }
 
 func runCommand(cmd *cobra.Command, path string) error {
-	logger.Info("Generating peer ID from key on the filesystem path", "path", path)
-
 	// Read the SSH key file
 	keyBytes, err := os.ReadFile(path)
 	if err != nil {

Diff for: cli/cmd/network/init/init.go

@@ -4,18 +4,20 @@
 package init
 
 import (
+	"crypto/ed25519"
 	"crypto/rand"
+	"crypto/x509"
+	"encoding/pem"
 	"fmt"
+	"os"
+	"path/filepath"
 
 	"github.com/agntcy/dir/cli/presenter"
-	"github.com/agntcy/dir/utils/logging"
 	"github.com/libp2p/go-libp2p/core/crypto"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/spf13/cobra"
 )
 
-var logger = logging.Logger("cli/network/init")
-
 var Command = &cobra.Command{
 	Use:   "init",
 	Short: "Generates the peer id from a newly generated private key, enabling connection to the DHT network",
@@ -25,30 +27,54 @@ a peer id will be generated that is needed for the host to connect to the networ
 
 Usage examples:
 
-1. Generate peer id from a newly generated private key:
+1. Generate peer id from a newly generated private key and save the key to the default location (~/.agntcy/dir/generated.key):
 
 	dirctl network init
 
+2. Generate peer id from a newly generated private key and save the key to a file:
+
+	dirctl network init --output /path/to/private/key.pem
+
 `,
 	RunE: func(cmd *cobra.Command, _ []string) error {
 		return runCommand(cmd)
 	},
 }
 
 func runCommand(cmd *cobra.Command) error {
-	logger.Info("Generating peer ID from a newly generated private key")
+	publicKey, privateKey, err := GenerateED25519OpenSSLKey()
+	if err != nil {
+		return fmt.Errorf("failed to generate ED25519 key pair: %w", err)
+	}
+
+	var filePath string
+	if opts.Output != "" {
+		filePath = opts.Output
+	} else {
+		homeDir, err := os.UserHomeDir()
+		if err != nil {
+			return fmt.Errorf("error getting home directory: %w", err)
+		}
+
+		filePath = filepath.Join(homeDir, ".agntcy/dir/generated.key")
+	}
+
+	err = os.MkdirAll(filepath.Dir(filePath), 0o0755) //nolint:mnd
+	if err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	err = os.WriteFile(filePath, privateKey, 0o600) //nolint:mnd
+	if err != nil {
+		return fmt.Errorf("failed to write private key to file: %w", err)
+	}
 
-	generatedKey, _, err := crypto.GenerateKeyPairWithReader(
-		crypto.Ed25519, // Select your key type. Ed25519 are nice short
-		-1,             // Select key length when possible (i.e. RSA).
-		rand.Reader,    // Always generate a random ID
-	)
+	pubKey, err := crypto.UnmarshalEd25519PublicKey(publicKey)
 	if err != nil {
-		return fmt.Errorf("failed to create identity key: %w", err)
+		return fmt.Errorf("failed to unmarshal public key: %w", err)
 	}
 
-	// Generate Peer ID from the public key
-	ID, err := peer.IDFromPublicKey(generatedKey.GetPublic())
+	ID, err := peer.IDFromPublicKey(pubKey)
 	if err != nil {
 		return fmt.Errorf("failed to generate peer ID from public key: %w", err)
 	}
@@ -57,3 +83,25 @@ func runCommand(cmd *cobra.Command) error {
 
 	return nil
 }
+
+func GenerateED25519OpenSSLKey() (ed25519.PublicKey, []byte, error) {
+	// Generate ED25519 key pair
+	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to generate ED25519 key pair: %w", err)
+	}
+
+	// Marshal the private key to PKCS#8 format
+	privBytes, err := x509.MarshalPKCS8PrivateKey(privateKey)
+	if err != nil {
+		return nil, nil, fmt.Errorf("failed to marshal private key: %w", err)
+	}
+
+	// Create PEM block
+	pemBlock := &pem.Block{
+		Type:  "PRIVATE KEY",
+		Bytes: privBytes,
+	}
+
+	return publicKey, pem.EncodeToMemory(pemBlock), nil
+}

Diff for: cli/cmd/network/init/options.go

@@ -0,0 +1,15 @@
+// Copyright AGNTCY Contributors (https://github.com/agntcy)
+// SPDX-License-Identifier: Apache-2.0
+
+package init
+
+var opts = &options{}
+
+type options struct {
+	Output string
+}
+
+func init() {
+	flags := Command.Flags()
+	flags.StringVarP(&opts.Output, "output", "o", "", "Path to the output file, where the generated private key will be stored.")
+}

Diff for: cli/go.mod

@@ -13,7 +13,6 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.17.0
 	github.com/agntcy/dir/api v0.2.0
 	github.com/agntcy/dir/client v0.2.0
-	github.com/agntcy/dir/utils v0.2.0
 	github.com/anchore/syft v1.19.0
 	github.com/libp2p/go-libp2p v0.41.1
 	github.com/mitchellh/mapstructure v1.5.0
@@ -46,6 +45,7 @@ require (
 	github.com/acobaugh/osrelease v0.1.0 // indirect
 	github.com/adrg/xdg v0.5.3 // indirect
 	github.com/agext/levenshtein v1.2.1 // indirect
+	github.com/agntcy/dir/utils v0.2.0 // indirect
 	github.com/anchore/archiver/v3 v3.5.3-0.20241210171143-5b1d8d1c7c51 // indirect
 	github.com/anchore/clio v0.0.0-20241115144204-29e89f9fa837 // indirect
 	github.com/anchore/fangs v0.0.0-20250326231402-da263204d38e // indirect

Diff for: e2e/dirctl_test.go

@@ -5,17 +5,13 @@ package e2e
 
 import (
 	"bytes"
-	"crypto/ed25519"
-	"crypto/rand"
-	"crypto/x509"
 	_ "embed"
-	"encoding/pem"
-	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
 
 	clicmd "github.com/agntcy/dir/cli/cmd"
+	initcmd "github.com/agntcy/dir/cli/cmd/network/init"
 	"github.com/onsi/ginkgo/v2"
 	"github.com/onsi/gomega"
 	"github.com/opencontainers/go-digest"
@@ -185,29 +181,29 @@ var _ = ginkgo.Describe("dirctl end-to-end tests", func() {
 
 	ginkgo.Context("network commands", func() {
 		var (
-			tempKeyDir  string
+			tempDir     string
 			tempKeyPath string
 		)
 
 		ginkgo.BeforeEach(func() {
 			// Create temporary directory for test keys
 			var err error
-			tempKeyDir, err = os.MkdirTemp("", "network-test")
+			tempDir, err = os.MkdirTemp("", "network-test")
 			gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 			// Generate OpenSSL-style ED25519 key
-			privateKey, err := generateED25519OpenSSLKey()
+			_, privateKey, err := initcmd.GenerateED25519OpenSSLKey()
 			gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
 			// Write the private key to a temporary file
-			tempKeyPath = filepath.Join(tempKeyDir, "test_key")
+			tempKeyPath = filepath.Join(tempDir, "test_key")
 			err = os.WriteFile(tempKeyPath, privateKey, 0o0600)
 			gomega.Expect(err).NotTo(gomega.HaveOccurred())
 		})
 
 		ginkgo.AfterEach(func() {
 			// Cleanup temporary directory
-			err := os.RemoveAll(tempKeyDir)
+			err := os.RemoveAll(tempDir)
 			gomega.Expect(err).NotTo(gomega.HaveOccurred())
 		})
 
@@ -263,82 +259,70 @@ var _ = ginkgo.Describe("dirctl end-to-end tests", func() {
 		})
 
 		ginkgo.Context("init command", func() {
-			ginkgo.It("should generate a new peer ID", func() {
+			ginkgo.It("should generate a new peer ID and save the key to specified output", func() {
+				outputPath := filepath.Join(tempDir, "generated.key")
 				var outputBuffer bytes.Buffer
 
 				initCmd := clicmd.RootCmd
 				initCmd.SetOut(&outputBuffer)
 				initCmd.SetArgs([]string{
 					"network",
 					"init",
+					"--output",
+					outputPath,
 				})
 
 				err := initCmd.Execute()
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-				// Verify that the output is not empty
+				// Verify that the output file exists
+				_, err = os.Stat(outputPath)
+				gomega.Expect(err).NotTo(gomega.HaveOccurred())
+
+				// Verify file permissions
+				info, err := os.Stat(outputPath)
+				gomega.Expect(err).NotTo(gomega.HaveOccurred())
+				gomega.Expect(info.Mode().Perm()).To(gomega.Equal(os.FileMode(0o0600)))
+
+				// Verify that the output is not empty and is a valid peer ID
 				output := strings.TrimSpace(outputBuffer.String())
 				gomega.Expect(output).NotTo(gomega.BeEmpty())
+				gomega.Expect(output).To(gomega.HavePrefix("12D3"))
 
-				// Store the first peer ID
-				firstPeerID := output
-
-				// Run the command again to verify we get a different peer ID
-				var secondBuffer bytes.Buffer
-				initCmd.SetOut(&secondBuffer)
+				// Verify that the generated key can be used with the info command
+				var infoBuffer bytes.Buffer
+				infoCmd := clicmd.RootCmd
+				infoCmd.SetOut(&infoBuffer)
+				infoCmd.SetArgs([]string{
+					"network",
+					"info",
+					outputPath,
+				})
 
-				err = initCmd.Execute()
+				err = infoCmd.Execute()
 				gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-				secondPeerID := strings.TrimSpace(secondBuffer.String())
-				gomega.Expect(secondPeerID).NotTo(gomega.BeEmpty())
-
-				// Verify that we get different peer IDs each time
-				gomega.Expect(secondPeerID).NotTo(gomega.Equal(firstPeerID))
+				// Verify that info command returns the same peer ID
+				infoOutput := strings.TrimSpace(infoBuffer.String())
+				gomega.Expect(infoOutput).To(gomega.Equal(output))
 			})
 
-			ginkgo.It("should generate valid peer IDs", func() {
+			ginkgo.It("should fail when output directory doesn't exist and cannot be created", func() {
+				// Try to write to a location that should fail
 				var outputBuffer bytes.Buffer
 
 				initCmd := clicmd.RootCmd
 				initCmd.SetOut(&outputBuffer)
 				initCmd.SetArgs([]string{
 					"network",
 					"init",
+					"--output",
+					"/nonexistent/directory/key.pem",
 				})
 
 				err := initCmd.Execute()
-				gomega.Expect(err).NotTo(gomega.HaveOccurred())
-
-				output := strings.TrimSpace(outputBuffer.String())
-
-				// Verify the peer ID format
-				// Peer IDs typically start with "12D3" in base58 encoding
-				gomega.Expect(output).To(gomega.HavePrefix("12D3"))
-				gomega.Expect(len(output)).To(gomega.BeNumerically(">", 40)) // Peer IDs should be reasonably long
+				gomega.Expect(err).To(gomega.HaveOccurred())
 			})
 		})
 	})
 })
-
-func generateED25519OpenSSLKey() ([]byte, error) {
-	// Generate ED25519 key pair
-	_, priv, err := ed25519.GenerateKey(rand.Reader)
-	if err != nil {
-		return nil, fmt.Errorf("failed to generate ED25519 key pair: %w", err)
-	}
-
-	// Marshal the private key to PKCS#8 format
-	privBytes, err := x509.MarshalPKCS8PrivateKey(priv)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal private key: %w", err)
-	}
-
-	// Create PEM block
-	pemBlock := &pem.Block{
-		Type:  "PRIVATE KEY",
-		Bytes: privBytes,
-	}
-
-	return pem.EncodeToMemory(pemBlock), nil
-}