Login, logout, publish

Author: gschier

README.md

@@ -8,3 +8,32 @@ This is the CLI for developing [Yaak](https://yaak.app) plugins.
 ```shell
 npm install -g @yaakapp/cli
 ```
+
+## Commands
+
+```
+$ yaakcli --help
+
+Generate, build, and debug plugins for Yaak, the most intuitive desktop API client
+
+Usage:
+  yaakcli [flags]
+  yaakcli [command]
+
+Available Commands:
+  build       Transpile code into a runnable plugin bundle
+  completion  Generate the autocompletion script for the specified shell
+  dev         Build plugin bundle continuously when the filesystem changes
+  generate    Generate a "Hello World" Yaak plugin
+  help        Help about any command
+  login       Login to Yaak via web browser
+  logout      Sign out of the Yaak CLI
+  publish     Publish a Yaak plugin version to the plugin registry
+  whoami      Print the current logged-in user's info
+
+Flags:
+  -h, --help      help for yaakcli
+      --version   Source directory to read from
+
+Use "yaakcli [command] --help" for more information about a command.
+```

api.go

@@ -0,0 +1,46 @@
+package yaakcli
+
+import (
+	"github.com/pterm/pterm"
+	"io"
+	"net/http"
+	"os"
+	"time"
+)
+
+func NewAPIRequest(method, path string, body io.Reader) *http.Request {
+	baseURL := prodStagingDevStr("https://api.yaak.app", "https://todo.yaak.app", "http://localhost:9444")
+	req, err := http.NewRequest(method, baseURL+"/api/v1"+path, body)
+	if err != nil {
+		pterm.Error.Printf("Failed to create API request: %s\n", err)
+		os.Exit(1)
+	}
+	return req
+}
+
+func SendAPIRequest(r *http.Request) []byte {
+	found, token, err := getAuthToken()
+	if err != nil {
+		ExitError(err.Error())
+	} else if !found {
+		pterm.Warning.Println("Not logged in")
+		pterm.Info.Println("Please run `yaakcli login`")
+		os.Exit(1)
+	}
+
+	r.Header.Set("X-Yaak-Session", token)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(r)
+	CheckError(err)
+
+	body, err := io.ReadAll(resp.Body)
+	CheckError(err)
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		pterm.Error.Printf("API %d → %s\n", resp.StatusCode, body)
+		os.Exit(1)
+	}
+
+	return body
+}

auth.go

@@ -0,0 +1,33 @@
+package yaakcli
+
+import (
+	"errors"
+	"github.com/zalando/go-keyring"
+)
+
+const keyringUser = "yaak"
+
+var keyringService = prodStagingDevStr("app.yaak.cli.Token", "app.yaak.cli.staging.Token", "app.yaak.cli.dev.Token")
+
+func getAuthToken() (bool, string, error) {
+	token, err := keyring.Get(keyringService, keyringUser)
+	if errors.Is(err, keyring.ErrNotFound) {
+		return false, "", nil
+	} else if err != nil {
+		return false, "", err
+	}
+
+	return true, token, nil
+}
+
+func storeAuthToken(token string) error {
+	return keyring.Set(keyringService, keyringUser, token)
+}
+
+func deleteAuthToken() error {
+	err := keyring.Delete(keyringService, keyringUser)
+	if errors.Is(err, keyring.ErrNotFound) {
+		return nil
+	}
+	return err
+}

cmd_login.go

@@ -0,0 +1,133 @@
+package yaakcli
+
+import (
+	"context"
+	"fmt"
+	"github.com/pkg/browser"
+	"github.com/pterm/pterm"
+	"github.com/spf13/cobra"
+	"net/http"
+	"net/url"
+	"os"
+	"os/signal"
+	"time"
+)
+
+var loginCmd = &cobra.Command{
+	Use:   "login",
+	Short: "Login to Yaak via web browser",
+	Long:  "Open a web browser to authenticate with Yaak. Works with all browsers including Safari.",
+	Run: func(cmd *cobra.Command, args []string) {
+		CheckError(deleteAuthToken())
+
+		pterm.Info.Println("Starting browser-based login...")
+
+		// Save the token to a config file
+		confirm := pterm.DefaultInteractiveConfirm
+		confirm.DefaultValue = true
+		open, err := confirm.Show("Open default browser")
+		CheckError(err)
+
+		if !open {
+			os.Exit(0)
+			return
+		}
+
+		// Create a channel to receive the auth token
+		tokenChan := make(chan string, 1)
+
+		// Create a context that we can cancel
+		_, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		// Set up a simple HTTP server to handle the OAuth callback
+		server := &http.Server{
+			Addr: "localhost:8085",
+		}
+
+		// Define the handler for the callback
+		http.HandleFunc("/oauth/callback", func(w http.ResponseWriter, r *http.Request) {
+			// Get the token from the query parameters
+			token := r.URL.Query().Get("token")
+			if token == "" {
+				w.WriteHeader(http.StatusBadRequest)
+				_, _ = fmt.Fprintf(w, "Error: No token provided")
+				return
+			}
+
+			// Send the token to the channel
+			tokenChan <- token
+
+			// Return a success message to the browser
+			redirectTo := prodStagingDevStr(
+				"https://yaak.app/login-cli/success",
+				"https://todo.yaak.app/login-cli/success",
+				"http://localhost:9444/login-cli/success",
+			)
+			http.Redirect(w, r, redirectTo, http.StatusFound)
+		})
+
+		// Start the server in a goroutine
+		go func() {
+			if err := server.ListenAndServe(); err != http.ErrServerClosed {
+				pterm.Error.Printf("HTTP server error: %v\n", err)
+				os.Exit(1)
+			}
+		}()
+
+		// Set up a signal handler to gracefully shut down the server
+		sigChan := make(chan os.Signal, 1)
+		signal.Notify(sigChan, os.Interrupt)
+
+		// Open the browser to the login page
+		redirect := "http://localhost:8085/oauth/callback"
+		loginURL := prodStagingDevStr(
+			"https://yaak.app/login-cli?redirect=",
+			"https://todo.yaak.app/login-cli?redirect=",
+			"http://localhost:9444/login-cli?redirect=",
+		) + url.QueryEscape(redirect)
+
+		// Open the browser based on the operating system
+		err = browser.OpenURL(loginURL)
+		if err != nil {
+			pterm.Error.Printf("Failed to open browser: %v\n", err)
+			pterm.Info.Println("Please open the following URL manually:")
+			pterm.Info.Println(loginURL)
+		}
+
+		// Wait for either the token, a signal, or a timeout
+		pterm.Info.Println("Waiting for authentication...")
+
+		select {
+		case token := <-tokenChan:
+			pterm.Success.Println("Authentication successful!")
+
+			// set password
+			err = storeAuthToken(token)
+			CheckError(err)
+
+			// Shutdown the server
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if err := server.Shutdown(ctx); err != nil {
+				pterm.Error.Printf("Server shutdown error: %v\n", err)
+			}
+
+		case <-sigChan:
+			pterm.Warning.Println("Interrupted by user. Shutting down...")
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if err := server.Shutdown(ctx); err != nil {
+				pterm.Error.Printf("Server shutdown error: %v\n", err)
+			}
+
+		case <-time.After(5 * time.Minute):
+			pterm.Warning.Println("Timeout waiting for authentication. Shutting down...")
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if err := server.Shutdown(ctx); err != nil {
+				pterm.Error.Printf("Server shutdown error: %v\n", err)
+			}
+		}
+	},
+}

cmd_logout.go

@@ -0,0 +1,16 @@
+package yaakcli
+
+import (
+	"github.com/pterm/pterm"
+	"github.com/spf13/cobra"
+)
+
+var logoutCmd = &cobra.Command{
+	Use:   "logout",
+	Short: "Sign out of the Yaak CLI",
+	Run: func(cmd *cobra.Command, args []string) {
+		err := deleteAuthToken()
+		CheckError(err)
+		pterm.Success.Println("Signed out of Yaak")
+	},
+}

cmd_publish.go

@@ -0,0 +1,101 @@
+package yaakcli
+
+import (
+	"archive/zip"
+	"fmt"
+	"github.com/pterm/pterm"
+	"github.com/spf13/cobra"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+var publishCmd = &cobra.Command{
+	Use:   "publish",
+	Short: "Publish a Yaak plugin version to the plugin registry",
+	Args:  cobra.MaximumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		pluginDir, err := os.Getwd()
+		CheckError(err)
+
+		if len(args) > 0 {
+			pluginDir, err = filepath.Abs(args[0])
+			CheckError(err)
+		}
+
+		zipPipeReader, zipPipeWriter := io.Pipe()
+
+		zipWriter := zip.NewWriter(zipPipeWriter)
+
+		selected := make(map[string]bool)
+		optionalFiles := []string{"README.md"}
+		requiredFiles := []string{"package.json", "package-lock.json", "build/index.js"}
+		for _, name := range optionalFiles {
+			selected[filepath.Clean(name)] = true
+		}
+
+		for _, name := range requiredFiles {
+			selected[filepath.Clean(name)] = true
+			_, err := os.Stat(filepath.Join(pluginDir, name))
+			if err != nil {
+				pterm.Warning.Printf("Missing required file: %s\n", name)
+				os.Exit(1)
+			}
+		}
+
+		pterm.Info.Println("Creating zip file ", pluginDir)
+
+		go func() {
+			defer func() {
+				CheckError(zipWriter.Close())
+				CheckError(zipPipeWriter.Close())
+			}()
+
+			err = filepath.Walk(pluginDir, func(path string, info os.FileInfo, err error) error {
+				if err != nil {
+					return err
+				}
+
+				if info.IsDir() {
+					return nil
+				}
+
+				relPath, err := filepath.Rel(pluginDir, path)
+				if err != nil {
+					return err
+				}
+
+				relPath = filepath.ToSlash(relPath) // Normalize for zip entries
+
+				if !selected[relPath] {
+					return nil
+				}
+
+				file, err := os.Open(path)
+				if err != nil {
+					return err
+				}
+				defer func(file *os.File) {
+					err := file.Close()
+					CheckError(err)
+				}(file)
+
+				writer, err := zipWriter.Create(relPath)
+				if err != nil {
+					return err
+				}
+
+				_, err = io.Copy(writer, file)
+
+				return err
+			})
+			CheckError(err)
+			pterm.Info.Println("Zip file created")
+		}()
+
+		req := NewAPIRequest("POST", "/plugins/publish", zipPipeReader)
+		body := SendAPIRequest(req)
+		pterm.Success.Println("Plugin published")
+		fmt.Printf("%s\n", body)
+	},
+}

cmd_root.go

@@ -23,6 +23,10 @@ func rootCmd(version string) *cobra.Command {
 	cmd.AddCommand(devCmd)
 	cmd.AddCommand(buildCmd)
 	cmd.AddCommand(generateCmd)
+	cmd.AddCommand(whoamiCmd)
+	cmd.AddCommand(loginCmd)
+	cmd.AddCommand(logoutCmd)
+	cmd.AddCommand(publishCmd)
 
 	cmd.Flags().BoolVar(&fVersion, "version", false, "Source directory to read from")
 

cmd_whoami.go

@@ -0,0 +1,16 @@
+package yaakcli
+
+import (
+	"github.com/pterm/pterm"
+	"github.com/spf13/cobra"
+)
+
+var whoamiCmd = &cobra.Command{
+	Use:   "whoami",
+	Short: "Print the current logged-in user's info",
+	Run: func(cmd *cobra.Command, args []string) {
+		req := NewAPIRequest("GET", "/whoami", nil)
+		body := SendAPIRequest(req)
+		pterm.Info.Printf("%s\n", body)
+	},
+}