first commit

Author: mirkobrombin

README.md

@@ -0,0 +1,33 @@
+# rfw-cli
+
+`rfw-cli` is the official command-line interface (CLI) tool for the **rfw** framework. It allows you to create, build, and run **rfw** projects from the command line.
+
+## Installation
+
+Ensure you have Go installed on your machine. Then, install `rfw-cli` with the following command:
+
+```bash
+go install github.com/rfwlab/rfw-cli@latest
+```
+
+## Usage
+
+To create a new **rfw** project, run the following command:
+
+```bash
+rfw-cli init github.com/username/project-name
+```
+
+## Server
+
+To start the **rfw** server, run the following command:
+
+```bash
+rfw-cli dev
+```
+
+To set a custom port and expose to the network, use the following flags:
+
+```bash
+rfw-cli dev --port 8080 --host
+```

cmd/root.go

@@ -0,0 +1,87 @@
+package cmd
+
+import (
+	"flag"
+	"fmt"
+	"os"
+
+	"github.com/rfwlab/rfw-cli/internal/initproj"
+	"github.com/rfwlab/rfw-cli/internal/server"
+	"github.com/rfwlab/rfw-cli/internal/utils"
+)
+
+func Execute() {
+	if len(os.Args) < 2 {
+		showHelp()
+		return
+	}
+
+	switch os.Args[1] {
+	case "init":
+		initProject(os.Args[2:])
+	case "dev":
+		startServer(os.Args[2:])
+	case "-h", "--help":
+		showHelp()
+	default:
+		fmt.Printf("Unknown command: %s\n", os.Args[1])
+		showHelp()
+	}
+}
+
+func startServer(args []string) {
+	devFlags := flag.NewFlagSet("dev", flag.ExitOnError)
+	port := devFlags.String("port", "8080", "Port from which the server will serve")
+	host := devFlags.Bool("host", false, "Expose the server to the network")
+
+	err := devFlags.Parse(args)
+	if err != nil {
+		fmt.Println("Error parsing flags:", err)
+		os.Exit(1)
+	}
+
+	fmt.Println("Starting server on port", *port)
+
+	srv := server.NewServer(*port, *host)
+	if err := srv.Start(); err != nil {
+		utils.Fatal("Server failed to start: ", err)
+	}
+}
+
+func initProject(args []string) {
+	initFlags := flag.NewFlagSet("init", flag.ExitOnError)
+
+	err := initFlags.Parse(args)
+	if err != nil {
+		fmt.Println("Error parsing flags:", err)
+		os.Exit(1)
+	}
+
+	remainingArgs := initFlags.Args()
+	if len(remainingArgs) < 1 {
+		fmt.Println("Please specify a project name: rfw-cli init <project-name>")
+		return
+	}
+
+	projectName := remainingArgs[0]
+	if err := initproj.InitProject(projectName); err != nil {
+		utils.Fatal("Failed to initialize project: ", err)
+	}
+}
+
+func showHelp() {
+	helpMessage := `
+Usage:
+  rfw-cli <command> [options]
+
+Commands:
+  init <project-name>           Initialize a new project
+  dev [--port <port>] [--host]  Start the development server
+  -h, --help                    Show this help message
+
+Examples:
+  rfw-cli init my-project
+  rfw-cli dev --port 9090 --host
+`
+	fmt.Println(helpMessage)
+}

go.mod

@@ -0,0 +1,11 @@
+module github.com/rfwlab/rfw-cli
+
+go 1.22.3
+
+require github.com/fatih/color v1.17.0
+
+require (
+	github.com/mattn/go-colorable v0.1.13 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	golang.org/x/sys v0.18.0 // indirect
+)

go.sum

@@ -0,0 +1,11 @@
+github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
+github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

internal/initproj/init.go

@@ -0,0 +1,90 @@
+package initproj
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func InitProject(projectName string) error {
+	if projectName == "" {
+		return fmt.Errorf("project name cannot be empty")
+	}
+
+	projectName = strings.Split(projectName, "/")[len(strings.Split(projectName, "/"))-1]
+
+	projectPath := projectName
+	if len(os.Args) > 3 {
+		projectPath = os.Args[3]
+	}
+
+	if _, err := os.Stat(projectPath); !os.IsNotExist(err) {
+		return fmt.Errorf("project directory already exists")
+	}
+
+	if err := os.Mkdir(projectPath, 0755); err != nil {
+		return fmt.Errorf("failed to create project directory: %w", err)
+	}
+
+	err := fs.WalkDir(TemplatesFS, ".", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if path == "." {
+			return nil
+		}
+
+		relPath := strings.TrimPrefix(path, "./")
+		targetPath := filepath.Join(projectPath, relPath)
+
+		if d.IsDir() {
+			return os.MkdirAll(targetPath, 0755)
+		}
+
+		content, err := TemplatesFS.ReadFile(path)
+		if err != nil {
+			return err
+		}
+
+		contentStr := strings.ReplaceAll(string(content), "{{packageName}}", projectName)
+
+		return os.WriteFile(targetPath, []byte(contentStr), 0644)
+	})
+	if err != nil {
+		return fmt.Errorf("failed to copy template files: %w", err)
+	}
+
+	if err := copyWasmExec(projectName); err != nil {
+		return fmt.Errorf("failed to copy wasm_exec.js: %w", err)
+	}
+
+	fmt.Printf("Project '%s' initialized successfully.\n", projectName)
+	return nil
+}
+
+func copyWasmExec(projectDir string) error {
+	cmd := exec.Command("go", "env", "GOROOT")
+	output, err := cmd.Output()
+	if err != nil {
+		return fmt.Errorf("failed to get GOROOT: %w", err)
+	}
+	goRoot := strings.TrimSpace(string(output))
+
+	srcPath := filepath.Join(goRoot, "misc", "wasm", "wasm_exec.js")
+	destPath := filepath.Join(projectDir, "wasm_exec.js")
+
+	input, err := os.ReadFile(srcPath)
+	if err != nil {
+		return fmt.Errorf("failed to read wasm_exec.js: %w", err)
+	}
+
+	if err := os.WriteFile(destPath, input, 0644); err != nil {
+		return fmt.Errorf("failed to write wasm_exec.js: %w", err)
+	}
+
+	return nil
+}

internal/initproj/template/main.go

@@ -0,0 +1,8 @@
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Welcome to {{packageName}}!")
+	fmt.Println("The init command is not fully implemented yet, template will be created as soon as the framework reach a stable structure.")
+}

internal/initproj/templates.go

@@ -0,0 +1,8 @@
+package initproj
+
+import (
+	"embed"
+)
+
+//go:embed template/*
+var TemplatesFS embed.FS

internal/server/server.go

@@ -0,0 +1,99 @@
+package server
+
+import (
+	"bufio"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+
+	"github.com/rfwlab/rfw-cli/internal/utils"
+)
+
+type Server struct {
+	Port   string
+	Host   bool
+	stopCh chan os.Signal
+}
+
+func NewServer(port string, host bool) *Server {
+	return &Server{
+		Port:   port,
+		Host:   host,
+		stopCh: make(chan os.Signal, 1),
+	}
+}
+
+func (s *Server) Start() error {
+	fs := http.FileServer(http.Dir("."))
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		utils.LogServeRequest(r)
+		s.handleFileRequest(w, r, fs)
+	})
+
+	signal.Notify(s.stopCh, syscall.SIGINT, syscall.SIGTERM)
+
+	localIP := ""
+	var err error
+	if s.Host {
+		localIP, err = utils.GetLocalIP()
+		if err != nil {
+			return err
+		}
+	}
+
+	utils.ClearScreen()
+	utils.PrintStartupInfo(s.Port, localIP, s.Host)
+
+	go func() {
+		if err := http.ListenAndServe(":"+s.Port, nil); err != nil {
+			utils.Fatal("Server failed: ", err)
+		}
+	}()
+
+	go s.listenForCommands()
+
+	<-s.stopCh
+	utils.Info("Server stopped.")
+	return nil
+}
+
+func (s *Server) handleFileRequest(w http.ResponseWriter, r *http.Request, fs http.Handler) {
+	if _, err := os.Stat("." + r.URL.Path); os.IsNotExist(err) {
+		http.ServeFile(w, r, "./index.html")
+	} else {
+		fs.ServeHTTP(w, r)
+	}
+}
+
+func (s *Server) listenForCommands() {
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		input, _ := reader.ReadString('\n')
+		input = strings.TrimSpace(input)
+
+		switch strings.ToLower(input) {
+		case "h":
+			utils.PrintHelp()
+		case "u":
+			utils.ClearScreen()
+			localIP, err := utils.GetLocalIP()
+			if err != nil {
+				utils.Fatal("Failed to get local IP address: ", err)
+			}
+			utils.PrintStartupInfo(s.Port, localIP, s.Host)
+		case "c", "q":
+			utils.Info("Closing the server...")
+			s.stopCh <- syscall.SIGINT
+			return
+		case "o":
+			utils.Info("Opening the browser...")
+			url := fmt.Sprintf("http://localhost:%s/", s.Port)
+			utils.OpenBrowser(url)
+		default:
+			utils.Info("Unknown command. Press 'h' for help.")
+		}
+	}
+}

internal/utils/network.go

@@ -0,0 +1,39 @@
+package utils
+
+import (
+	"fmt"
+	"net"
+	"os/exec"
+	"runtime"
+)
+
+func GetLocalIP() (string, error) {
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		return "", err
+	}
+
+	for _, addr := range addrs {
+		if ipNet, ok := addr.(*net.IPNet); ok && !ipNet.IP.IsLoopback() && ipNet.IP.To4() != nil {
+			return ipNet.IP.String(), nil
+		}
+	}
+
+	return "", fmt.Errorf("no local IP address found")
+}
+
+func OpenBrowser(url string) {
+	var cmd *exec.Cmd
+	switch runtime.GOOS {
+	case "windows":
+		cmd = exec.Command("cmd", "/c", "start", url)
+	case "darwin":
+		cmd = exec.Command("open", url)
+	default:
+		cmd = exec.Command("xdg-open", url)
+	}
+
+	if err := cmd.Start(); err != nil {
+		fmt.Printf("Failed to open browser: %v\n", err)
+	}
+}