dsfx/cmd/dsfxctl/main.go

package main

import (
	"context"
	"crypto/ed25519"
	"encoding/base64"
	"errors"
	"flag"
	"fmt"
	"log/slog"
	"net"
	"os"
	"path/filepath"

	"koti.casa/numenor-labs/dsfx/pkg/crypto/identity"
	"koti.casa/numenor-labs/dsfx/pkg/logging"
	"koti.casa/numenor-labs/dsfx/pkg/network"
)

func main() {
	ctx := context.Background()

	// ---------------------------------------------------------------------------
	// Logger

	opts := &slog.HandlerOptions{
		AddSource: false,
		Level:     slog.LevelDebug,
	}
	logger := slog.New(slog.NewTextHandler(os.Stdout, opts))

	// Everything in the application will attempt to use the logger in stored in
	// the context, but we also set the default with slog as a fallback. In cases
	// where the context is not available, or the context is not a child of the
	// context with the logger, the default logger will be used.
	slog.SetDefault(logger)
	ctx = logging.WithContext(ctx, logger)

	homedir, err := os.UserHomeDir()
	if err != nil {
		logger.ErrorContext(ctx, "failed to get home directory", slog.Any("error", err))
		os.Exit(1)
	}

	flagDir := flag.String("dir", filepath.Join(homedir, ".dsfxctl"), "data directory")

	err = os.Mkdir(*flagDir, 0777)
	if errors.Is(err, os.ErrExist) {
		// If the directory already exists, we can ignore the error.
		err = nil
	}
	if err != nil {
		logger.ErrorContext(ctx, "failed to create directory", slog.Any("error", err))
		os.Exit(1)
	}

	keyFile, err := os.Open(filepath.Join(*flagDir, "key"))
	if err != nil {
		logger.WarnContext(ctx, "key file is missing, reinitializing")
		logger.WarnContext(ctx, "if this is your first time running dsfxctl, you can ignore this")
	}
	if keyFile == nil {
		logger.InfoContext(ctx, "generating new key")
		keyFile, err = os.Create(filepath.Join(*flagDir, "key"))
		if err != nil {
			logger.ErrorContext(ctx, "failed to create key file", slog.Any("error", err))
			os.Exit(1)
		}
		privkey, err := identity.Generate()
		if err != nil {
			logger.ErrorContext(ctx, "failed to generate key", slog.Any("error", err))
			os.Exit(1)
		}

		_, err = keyFile.Write([]byte(base64.StdEncoding.EncodeToString(privkey)))
		if err != nil {
			logger.ErrorContext(ctx, "failed to write key", slog.Any("error", err))
			os.Exit(1)
		}
	}
	defer keyFile.Close()

	// ---------------------------------------------------------------------------
	// Commands

	flag.Parse()

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: dsfxctl [command] [args]\n")
		fmt.Fprintf(os.Stderr, "Commands:\n")
		fmt.Fprintf(os.Stderr, "  test <remote_addr>  Test the connection to the server\n")
		fmt.Fprintf(os.Stderr, "Flags:\n")
		flag.PrintDefaults()
	}

	id, err := identity.LoadSigningKeyFromFile(filepath.Join(*flagDir, "key"))
	if err != nil {
		logger.ErrorContext(ctx, "failed to load private key", slog.Any("error", err))
		os.Exit(1)
	}

	laddr := network.NewAddr(
		net.ParseIP("0.0.0.0"),
		0, // port 0 means any available port
		identity.ToPublicKey(id),
	)

	logger.DebugContext(ctx, "using addr", slog.String("address", laddr.String()))

	switch flag.Arg(0) {
	case "test":
		raddrRaw := flag.Arg(1)
		if raddrRaw == "" {
			logger.ErrorContext(ctx, "no remote address provided")
			os.Exit(1)
		}
		testConnection(ctx, id, laddr, raddrRaw)
	case "":
		logger.InfoContext(ctx, "no command provided")
		os.Exit(1)
	default:
		logger.InfoContext(ctx, "unknown command")
		os.Exit(1)
	}
}

func testConnection(ctx context.Context, id ed25519.PrivateKey, laddr *network.Addr, raddrRaw string) {
	logger := logging.FromContext(context.Background())

	raddr, err := network.ParseAddr(raddrRaw)
	if err != nil {
		logger.ErrorContext(ctx, "failed to parse server address", slog.Any("error", err))
		return
	}

	conn, err := network.Dial(ctx, id, laddr, raddr)
	if err != nil {
		logger.ErrorContext(ctx, "failed to connect", slog.Any("error", err))
		return
	}
	defer conn.Close()
}