feat: Implement ./contribs/gnodev command

contribs/Makefile

@@ -4,9 +4,10 @@ help:
 	@cat Makefile | grep '^[a-z][^:]*:' | cut -d: -f1 | sort | sed 's/^/  /'
 
 .PHONY: install
-install: install.gnomd
+install: install.gnomd install.gnodev
 
-install.gnomd:; cd gnomd && go install .
+install.gnomd:;  cd gnomd && go install .
+install.gnodev:; $(MAKE) -C ./gnodev install
 
 .PHONY: clean
 clean:

contribs/gnodev/Makefile

@@ -0,0 +1,9 @@
+GNOROOT_DIR ?= $(abspath $(lastword $(MAKEFILE_LIST))/../../../)
+
+GOBUILD_FLAGS := -ldflags "-X github.com/gnolang/gno/gnovm/pkg/gnoenv._GNOROOT=$(GNOROOT_DIR)"
+
+install:
+	go install $(GOBUILD_FLAGS) ./cmd/gnodev
+
+build:
+	go build $(GOBUILD_FLAGS) -o build/gnodev ./cmd/gno

contribs/gnodev/cmd/gnodev/main.go

@@ -0,0 +1,356 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+	gnodev "github.com/gnolang/gno/contribs/gnodev/pkg/dev"
+	"github.com/gnolang/gno/gno.land/pkg/gnoweb"
+	"github.com/gnolang/gno/gnovm/pkg/gnoenv"
+	"github.com/gnolang/gno/gnovm/pkg/gnomod"
+	"github.com/gnolang/gno/tm2/pkg/commands"
+	tmlog "github.com/gnolang/gno/tm2/pkg/log"
+	osm "github.com/gnolang/gno/tm2/pkg/os"
+)
+
+type devCfg struct {
+	bindAddr string
+	minimal  bool
+	verbose  bool
+	noWatch  bool
+}
+
+var defaultDevOptions = &devCfg{
+	bindAddr: "127.0.0.1:8888",
+}
+
+func main() {
+	cfg := &devCfg{}
+
+	stdio := commands.NewDefaultIO()
+	cmd := commands.NewCommand(
+		commands.Metadata{
+			Name:       "gnodev",
+			ShortUsage: "gnodev [flags] <path>",
+			ShortHelp:  "GnoDev run a node for dev purpose, it will load the given package path",
+		},
+		cfg,
+		func(_ context.Context, args []string) error {
+			return execDev(cfg, args, stdio)
+		})
+
+	if err := cmd.ParseAndRun(context.Background(), os.Args[1:]); err != nil {
+		fmt.Fprintf(os.Stderr, "%+v\n", err)
+		os.Exit(1)
+	}
+}
+
+func (c *devCfg) RegisterFlags(fs *flag.FlagSet) {
+	fs.StringVar(
+		&c.bindAddr,
+		"web-bind",
+		defaultDevOptions.bindAddr,
+		"verbose output when deving",
+	)
+
+	fs.BoolVar(
+		&c.minimal,
+		"minimal",
+		defaultDevOptions.verbose,
+		"don't load example folder packages along default transaction",
+	)
+
+	fs.BoolVar(
+		&c.verbose,
+		"verbose",
+		defaultDevOptions.verbose,
+		"verbose output when deving",
+	)
+
+	fs.BoolVar(
+		&c.noWatch,
+		"no-watch",
+		defaultDevOptions.noWatch,
+		"watch for files change",
+	)
+
+}
+
+func execDev(cfg *devCfg, args []string, io commands.IO) error {
+	ctx, cancel := context.WithCancelCause(context.Background())
+	defer cancel(nil)
+
+	// guess root dir
+	gnoroot := gnoenv.RootDir()
+
+	pkgpaths, err := parseArgsPackages(io, args)
+	if err != nil {
+		return fmt.Errorf("unable to parse package paths: %w", err)
+	}
+
+	// noopLogger := log.NewTMLogger(log.NewSyncWriter(io.Out))
+	noopLogger := tmlog.NewNopLogger()
+
+	// RAWTerm setup
+	rt := gnodev.NewRawTerm()
+	{
+		restore, err := rt.Init()
+		if err != nil {
+			return fmt.Errorf("unable to init raw term for dev: %s", err)
+		}
+		defer restore()
+
+		// correctly format output for terminal
+		io.SetOut(commands.WriteNopCloser(rt))
+
+		// Setup trap signal
+		osm.TrapSignal(func() {
+			restore()
+			cancel(nil)
+		})
+	}
+
+	nodeOut := rt.NamespacedWriter("Node")
+	webOut := rt.NamespacedWriter("GnoWeb")
+	keyOut := rt.NamespacedWriter("KeyPress")
+
+	var dnode *gnodev.Node
+	{
+		var err error
+		// XXX: redirect node to output file
+		dnode, err = setupDevNode(ctx, noopLogger, cfg, pkgpaths, gnoroot)
+		if err != nil {
+			return err // already formated in setupDevNode
+		}
+		defer dnode.Close()
+	}
+
+	fmt.Fprintf(nodeOut, "Listener: %s\n", dnode.GetRemoteAddress())
+
+	// setup files watcher
+	w, err := setupPkgsWatcher(cfg, dnode.ListPkgs())
+	if err != nil {
+		return fmt.Errorf("unable to watch for files change: %w", err)
+	}
+
+	ccpath := make(chan []string, 1)
+	go func() {
+		defer close(ccpath)
+
+		const debounceTimeout = time.Millisecond * 500
+
+		if err := handleDebounce(ctx, w, ccpath, debounceTimeout); err != nil {
+			cancel(err)
+		}
+	}()
+
+	// Gnoweb setup
+	server := setupGnowebServer(cfg, dnode, rt)
+
+	l, err := net.Listen("tcp", cfg.bindAddr)
+	if err != nil {
+		return fmt.Errorf("unable to listen to %q: %w", cfg.bindAddr, err)
+	}
+
+	go func() {
+		var err error
+		if srvErr := server.Serve(l); srvErr != nil {
+			err = fmt.Errorf("HTTP server stopped with error: %w", srvErr)
+		}
+		cancel(err)
+	}()
+	defer server.Close()
+
+	fmt.Fprintf(webOut, "Listener: %s\n", l.Addr())
+
+	// Print basic infos
+	fmt.Fprintf(nodeOut, "Default Address: %s\n", gnodev.DefaultCreator.String())
+	fmt.Fprintf(nodeOut, "Chain ID: %s\n", dnode.Config().ChainID())
+
+	rt.Taskf("[Ready]", "for commands and help, press `h`")
+
+	cckey := listenForKeyPress(keyOut, rt)
+	for {
+		var err error
+
+		select {
+		case <-ctx.Done():
+			return context.Cause(ctx)
+		case paths := <-ccpath:
+			for _, path := range paths {
+				rt.Taskf("HotReload", "path %q has been modified", path)
+			}
+
+			fmt.Fprintln(nodeOut, "Loading package updates...")
+			if err = dnode.UpdatePackages(paths...); err != nil {
+				checkForError(rt, err)
+				continue
+			}
+
+			fmt.Fprintln(nodeOut, "Reloading...")
+			err = dnode.Reload(ctx)
+			checkForError(rt, err)
+		case key, ok := <-cckey:
+			if !ok {
+				cancel(nil)
+				continue
+			}
+
+			if cfg.verbose {
+				fmt.Fprintf(keyOut, "<%s>\n", key.String())
+			}
+
+			switch key {
+			case 'h', 'H':
+				printHelper(rt)
+			case 'r', 'R':
+				fmt.Fprintln(nodeOut, "Reloading all packages...")
+				err = dnode.ReloadAll(ctx)
+				checkForError(nodeOut, err)
+			case gnodev.KeyCtrlR:
+				fmt.Fprintln(nodeOut, "Reseting state...")
+				err = dnode.Reset(ctx)
+				checkForError(nodeOut, err)
+			case gnodev.KeyCtrlC:
+				cancel(nil)
+			default:
+			}
+		}
+	}
+}
+
+// XXX: Automatize this the same way command does
+func printHelper(rt *gnodev.RawTerm) {
+	rt.Taskf("Helper", `
+Gno Dev Helper:
+  h, H        Help - display this message
+  r, R        Reload - Reload all packages to take change into account.
+  Ctrl+R      Reset - Reset application state.
+  Ctrl+C      Exit - Exit the application
+`)
+}
+
+func handleDebounce(ctx context.Context, watcher *fsnotify.Watcher, changedPathsCh chan<- []string, timeout time.Duration) error {
+	var debounceTimer <-chan time.Time
+	pathList := []string{}
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case watchErr := <-watcher.Errors:
+			return fmt.Errorf("watch error: %w", watchErr)
+		case <-debounceTimer:
+			changedPathsCh <- pathList
+			// Reset pathList and debounceTimer
+			pathList = []string{}
+			debounceTimer = nil
+		case evt := <-watcher.Events:
+			if evt.Op == fsnotify.Write {
+				pathList = append(pathList, evt.Name)
+				debounceTimer = time.After(timeout)
+			}
+		}
+	}
+}
+
+func setupPkgsWatcher(cfg *devCfg, pkgs []gnomod.Pkg) (*fsnotify.Watcher, error) {
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, fmt.Errorf("unable to watch files: %w", err)
+	}
+
+	if cfg.noWatch {
+		// noop watcher
+		return watcher, nil
+	}
+
+	for _, pkg := range pkgs {
+		if err := watcher.Add(pkg.Dir); err != nil {
+			return nil, fmt.Errorf("unable to watch %q: %w", pkg.Dir, err)
+		}
+	}
+
+	return watcher, nil
+}
+
+// setupDevNode initializes and returns a new DevNode.
+func setupDevNode(ctx context.Context, logger tmlog.Logger, cfg *devCfg, pkgspath []string, gnoroot string) (*gnodev.Node, error) {
+	if !cfg.minimal {
+		examplesDir := filepath.Join(gnoroot, "examples")
+		pkgspath = append(pkgspath, examplesDir)
+	}
+
+	return gnodev.NewDevNode(ctx, logger, pkgspath)
+}
+
+// setupGnowebServer initializes and starts the Gnoweb server.
+func setupGnowebServer(cfg *devCfg, dnode *gnodev.Node, rt *gnodev.RawTerm) *http.Server {
+	var server http.Server
+
+	webConfig := gnoweb.NewDefaultConfig()
+	webConfig.RemoteAddr = dnode.GetRemoteAddress()
+
+	loggerweb := tmlog.NewTMLogger(rt.NamespacedWriter("GnoWeb"))
+	loggerweb.SetLevel(tmlog.LevelDebug)
+
+	app := gnoweb.MakeApp(loggerweb, webConfig)
+
+	server.ReadHeaderTimeout = 60 * time.Second
+	server.Handler = app.Router
+
+	return &server
+}
+
+func parseArgsPackages(io commands.IO, args []string) (paths []string, err error) {
+	paths = make([]string, len(args))
+	for i, arg := range args {
+		abspath, err := filepath.Abs(arg)
+		if err != nil {
+			return nil, fmt.Errorf("invalid path %q: %w", arg, err)
+		}
+
+		ppath, err := gnomod.FindRootDir(abspath)
+		if err != nil {
+			return nil, fmt.Errorf("unable to find root dir of %q: %w", abspath, err)
+		}
+
+		paths[i] = ppath
+	}
+
+	return paths, nil
+}
+
+func listenForKeyPress(w io.Writer, rt *gnodev.RawTerm) <-chan gnodev.KeyPress {
+	cc := make(chan gnodev.KeyPress, 1)
+	go func() {
+		defer close(cc)
+		for {
+			key, err := rt.ReadKeyPress()
+			if err != nil {
+				fmt.Fprintf(w, "unable to read keypress: %s\n", err.Error())
+				return
+			}
+
+			cc <- key
+		}
+	}()
+
+	return cc
+}
+
+func checkForError(w io.Writer, err error) {
+	if err != nil {
+		fmt.Fprintf(w, "", "[ERROR] - %s\n", err.Error())
+	} else {
+		fmt.Fprintln(w, "", "[DONE]")
+	}
+}