Cli setup command

cli/common/flags.go

@@ -21,6 +21,12 @@ import (
 )
 
 var GlobalFlags = append([]cli.Flag{
+ &cli.StringFlag{
+ EnvVars: []string{"WOODPECKER_CONFIG"},
+ Name: "config",
+ Aliases: []string{"c"},
+ Usage: "path to config file",
+ },
  &cli.StringFlag{
  EnvVars: []string{"WOODPECKER_TOKEN"},
  Name: "token",

cli/common/hooks.go

@@ -8,6 +8,7 @@ import (
  "github.com/rs/zerolog/log"
  "github.com/urfave/cli/v2"
 
+ "go.woodpecker-ci.org/woodpecker/v2/cli/internal/config"
  "go.woodpecker-ci.org/woodpecker/v2/cli/update"
 )
 
@@ -17,7 +18,7 @@ var (
 )
 
 func Before(c *cli.Context) error {
- if err := SetupGlobalLogger(c); err != nil {
+ if err := setupGlobalLogger(c); err != nil {
  return err
  }
 
@@ -49,7 +50,7 @@ func Before(c *cli.Context) error {
  }
  }()
 
- return nil
+ return config.Load(c)
 }
 
 func After(_ *cli.Context) error {

cli/common/zerologger.go

@@ -20,6 +20,6 @@ import (
  "go.woodpecker-ci.org/woodpecker/v2/shared/logger"
 )
 
-func SetupGlobalLogger(c *cli.Context) error {
+func setupGlobalLogger(c *cli.Context) error {
  return logger.SetupGlobalLogger(c, false)
 }

cli/internal/config/config.go

@@ -0,0 +1,131 @@
+package config
+
+import (
+ "encoding/json"
+ "errors"
+ "os"
+
+ "github.com/adrg/xdg"
+ "github.com/rs/zerolog/log"
+ "github.com/urfave/cli/v2"
+ "github.com/zalando/go-keyring"
+)
+
+type Config struct {
+ ServerURL string `json:"server_url"`
+ Token string `json:"-"`
+ LogLevel string `json:"log_level"`
+}
+
+func Load(c *cli.Context) error {
+ // If the command is setup, we don't need to load the config
+ if firstArg := c.Args().First(); firstArg == "setup" {
+ return nil
+ }
+
+ config, err := Get(c, c.String("config"))
+ if err != nil {
+ return err
+ }
+
+ if config == nil && !c.IsSet("server-url") && !c.IsSet("token") {
+ log.Info().Msg("The woodpecker-cli is not setup yet. Please run `woodpecker-cli setup`")
+ return errors.New("woodpecker-cli is not setup")
+ }
+
+ if !c.IsSet("server") {
+ err = c.Set("server", config.ServerURL)
+ if err != nil {
+ return err
+ }
+ }
+
+ if !c.IsSet("token") {
+ err = c.Set("token", config.Token)
+ if err != nil {
+ return err
+ }
+ }
+
+ if !c.IsSet("log-level") {
+ err = c.Set("log-level", config.LogLevel)
+ if err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func getConfigPath(configPath string) (string, error) {
+ if configPath != "" {
+ return configPath, nil
+ }
+
+ configPath, err := xdg.ConfigFile("woodpecker/config.json")
+ if err != nil {
+ return "", err
+ }
+
+ return configPath, nil
+}
+
+func Get(ctx *cli.Context, _configPath string) (*Config, error) {
+ configPath, err := getConfigPath(_configPath)
+ if err != nil {
+ return nil, err
+ }
+
+ content, err := os.ReadFile(configPath)
+ if err != nil && !os.IsNotExist(err) {
+ log.Debug().Err(err).Msg("Failed to read the config file")
+ return nil, err
+ } else if err != nil && os.IsNotExist(err) {
+ log.Debug().Msg("The config file does not exist")
+ return nil, nil
+ }
+
+ c := &Config{}
+ err = json.Unmarshal(content, c)
+ if err != nil {
+ return nil, err
+ }
+
+ // load token from keyring
+ service := ctx.App.Name
+ secret, err := keyring.Get(service, c.ServerURL)
+ if err != nil && !errors.Is(err, keyring.ErrNotFound) {
+ return nil, err
+ }
+ if err == nil {
+ c.Token = secret
+ }
+
+ return c, nil
+}
+
+func Save(ctx *cli.Context, _configPath string, c *Config) error {
+ config, err := json.Marshal(c)
+ if err != nil {
+ return err
+ }
+
+ configPath, err := getConfigPath(_configPath)
+ if err != nil {
+ return err
+ }
+
+ // save token to keyring
+ service := ctx.App.Name
+ err = keyring.Set(service, c.ServerURL, c.Token)
+ if err != nil {
+ return err
+ }
+
+ err = os.WriteFile(configPath, config, 0o600)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}

cli/setup/setup.go

@@ -0,0 +1,88 @@
+package setup
+
+import (
+ "errors"
+ "strings"
+
+ "github.com/rs/zerolog/log"
+ "github.com/urfave/cli/v2"
+
+ "go.woodpecker-ci.org/woodpecker/v2/cli/internal/config"
+ "go.woodpecker-ci.org/woodpecker/v2/cli/setup/ui"
+)
+
+// Command exports the setup command.
+var Command = &cli.Command{
+ Name: "setup",
+ Usage: "setup the woodpecker-cli for the first time",
+ Flags: []cli.Flag{
+ &cli.StringFlag{
+ Name: "server-url",
+ Usage: "The URL of the woodpecker server",
+ },
+ &cli.StringFlag{
+ Name: "token",
+ Usage: "The token to authenticate with the woodpecker server",
+ },
+ },
+ Action: setup,
+}
+
+func setup(c *cli.Context) error {
+ _config, err := config.Get(c, c.String("config"))
+ if err != nil {
+ return err
+ } else if _config != nil {
+ setupAgain, err := ui.Confirm("The woodpecker-cli was already configured. Do you want to configure it again?")
+ if err != nil {
+ return err
+ }
+
+ if !setupAgain {
+ log.Info().Msg("Configuration skipped")
+ return nil
+ }
+ }
+
+ serverURL := c.String("server-url")
+
+ if serverURL == "" {
+ serverURL, err = ui.Ask("Enter the URL of the woodpecker server", "https://woodpecker-ci.org", true)
+ if err != nil {
+ return err
+ }
+
+ if serverURL == "" {
+ return errors.New("server URL cannot be empty")
+ }
+ }
+
+ if !strings.Contains(serverURL, "://") {
+ serverURL = "https://" + serverURL
+ }
+
+ token := c.String("token")
+ if token == "" {
+ token, err = receiveTokenFromUI(c.Context, serverURL)
+ if err != nil {
+ return err
+ }
+
+ if token == "" {
+ return errors.New("no token received from the UI")
+ }
+ }
+
+ err = config.Save(c, c.String("config"), &config.Config{
+ ServerURL: serverURL,
+ Token: token,
+ LogLevel: "info",
+ })
+ if err != nil {
+ return err
+ }
+
+ log.Info().Msg("The woodpecker-cli has been successfully setup")
+
+ return nil
+}

cli/setup/token_fetcher.go

@@ -0,0 +1,117 @@
+package setup
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "math/rand"
+ "net/http"
+ "os/exec"
+ "runtime"
+ "time"
+
+ "github.com/gin-gonic/gin"
+ "github.com/rs/zerolog/log"
+)
+
+func receiveTokenFromUI(c context.Context, serverURL string) (string, error) {
+ port := randomPort()
+
+ tokenReceived := make(chan string)
+
+ srv := &http.Server{Addr: fmt.Sprintf(":%d", port)}
+ srv.Handler = setupRouter(tokenReceived)
+
+ go func() {
+ log.Debug().Msgf("Listening for token response on :%d", port)
+ _ = srv.ListenAndServe()
+ }()
+
+ defer func() {
+ log.Debug().Msg("Shutting down server")
+ _ = srv.Shutdown(c)
+ }()
+
+ err := openBrowser(fmt.Sprintf("%s/cli/auth?port=%d", serverURL, port))
+ if err != nil {
+ return "", err
+ }
+
+ // wait for token to be received or timeout
+ select {
+ case token := <-tokenReceived:
+ return token, nil
+ case <-c.Done():
+ return "", c.Err()
+ case <-time.After(5 * time.Minute):
+ return "", errors.New("timed out waiting for token")
+ }
+}
+
+func setupRouter(tokenReceived chan string) *gin.Engine {
+ gin.SetMode(gin.ReleaseMode)
+ e := gin.New()
+ e.UseRawPath = true
+ e.Use(gin.Recovery())
+
+ e.Use(func(c *gin.Context) {
+ c.Writer.Header().Set("Access-Control-Allow-Origin", "*") // TODO: change to serverURL
+ c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
+ c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
+ c.Writer.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT")
+
+ if c.Request.Method == "OPTIONS" {
+ c.AbortWithStatus(204)
+ return
+ }
+
+ c.Next()
+ })
+
+ e.POST("/token", func(c *gin.Context) {
+ data := struct {
+ Token string `json:"token"`
+ }{}
+
+ err := c.BindJSON(&data)
+ if err != nil {
+ log.Debug().Err(err).Msg("Failed to bind JSON")
+ c.JSON(400, gin.H{
+ "error": "invalid request",
+ })
+ return
+ }
+
+ tokenReceived <- data.Token
+
+ c.JSON(200, gin.H{
+ "ok": "true",
+ })
+ })
+
+ return e
+}
+
+func openBrowser(url string) error {
+ var err error
+
+ log.Debug().Msgf("Opening browser with URL: %s", url)
+
+ switch runtime.GOOS {
+ case "linux":
+ err = exec.Command("xdg-open", url).Start()
+ case "windows":
+ err = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
+ case "darwin":
+ err = exec.Command("open", url).Start()
+ default:
+ err = fmt.Errorf("unsupported platform")
+ }
+ return err
+}
+
+func randomPort() int {
+ s1 := rand.NewSource(time.Now().UnixNano())
+ r1 := rand.New(s1)
+ return r1.Intn(10000) + 20000
+}