Merge branch 'authenticate'

Author: ivpusic

.github/workflows/release.yml

@@ -0,0 +1,32 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v6
+        with:
+          distribution: goreleaser
+          version: "~> v2"
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.goreleaser.yml

@@ -0,0 +1,54 @@
+version: 2
+
+project_name: dune-cli
+
+before:
+  hooks:
+    - go mod tidy
+
+builds:
+  - main: ./cmd
+    binary: dune
+    env:
+      - CGO_ENABLED=0
+    ldflags:
+      - -s -w
+      - -X main.version={{.Version}}
+      - -X main.commit={{.Commit}}
+      - -X main.date={{.Date}}
+    goos:
+      - linux
+      - darwin
+      - windows
+    goarch:
+      - amd64
+      - arm64
+
+archives:
+  - format: tar.gz
+    name_template: >-
+      {{ .ProjectName }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}
+    format_overrides:
+      - goos: windows
+        format: zip
+
+checksum:
+  name_template: "checksums.txt"
+
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - "^docs:"
+      - "^test:"
+      - "^ci:"
+      - "^chore:"
+
+release:
+  github:
+    owner: duneanalytics
+    name: cli
+  draft: false
+  prerelease: auto
+  extra_files:
+    - glob: install.sh

authconfig/authconfig.go

@@ -0,0 +1,101 @@
+package authconfig
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"gopkg.in/yaml.v3"
+)
+
+// Config holds the persisted CLI configuration.
+type Config struct {
+	APIKey string `yaml:"api_key"`
+}
+
+// configDirFunc allows tests to override the config directory.
+var (
+	configDirFunc = defaultDir
+	configMu      sync.RWMutex
+)
+
+func defaultDir() (string, error) {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(home, ".config", "dune"), nil
+}
+
+// SetDirFunc overrides the config directory function (for testing).
+func SetDirFunc(fn func() (string, error)) {
+	configMu.Lock()
+	defer configMu.Unlock()
+	configDirFunc = fn
+}
+
+// ResetDirFunc restores the default config directory function.
+func ResetDirFunc() {
+	configMu.Lock()
+	defer configMu.Unlock()
+	configDirFunc = defaultDir
+}
+
+// Dir returns the config directory path ($HOME/.config/dune).
+func Dir() (string, error) {
+	configMu.RLock()
+	defer configMu.RUnlock()
+	return configDirFunc()
+}
+
+// Path returns the full path to the config file.
+func Path() (string, error) {
+	dir, err := Dir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(dir, "config.yaml"), nil
+}
+
+// Load reads and parses the config file. Returns nil, nil if the file does not exist.
+func Load() (*Config, error) {
+	p, err := Path()
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := os.ReadFile(p)
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	var cfg Config
+	if err := yaml.Unmarshal(data, &cfg); err != nil {
+		return nil, err
+	}
+	return &cfg, nil
+}
+
+// Save writes the config to disk, creating the directory (0700) and file (0600) as needed.
+func Save(cfg *Config) error {
+	p, err := Path()
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
+		return err
+	}
+
+	data, err := yaml.Marshal(cfg)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(p, data, 0o600)
+}

authconfig/authconfig_test.go

@@ -0,0 +1,78 @@
+package authconfig_test
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/duneanalytics/cli/authconfig"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func setupTempDir(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	authconfig.SetDirFunc(func() (string, error) { return dir, nil })
+	t.Cleanup(authconfig.ResetDirFunc)
+	return dir
+}
+
+func TestSaveAndLoad(t *testing.T) {
+	setupTempDir(t)
+
+	want := &authconfig.Config{APIKey: "dune_test_key_123"}
+	require.NoError(t, authconfig.Save(want))
+
+	got, err := authconfig.Load()
+	require.NoError(t, err)
+	assert.Equal(t, want.APIKey, got.APIKey)
+}
+
+func TestLoadNonExistent(t *testing.T) {
+	setupTempDir(t)
+
+	cfg, err := authconfig.Load()
+	assert.NoError(t, err)
+	assert.Nil(t, cfg)
+}
+
+func TestLoadMalformedYAML(t *testing.T) {
+	dir := setupTempDir(t)
+
+	err := os.WriteFile(filepath.Join(dir, "config.yaml"), []byte(":\tbad\nyaml{["), 0o600)
+	require.NoError(t, err)
+
+	_, err = authconfig.Load()
+	assert.Error(t, err)
+}
+
+func TestSaveCreatesDir(t *testing.T) {
+	tmp := t.TempDir()
+	nested := filepath.Join(tmp, "sub", "dir")
+	authconfig.SetDirFunc(func() (string, error) { return nested, nil })
+	t.Cleanup(authconfig.ResetDirFunc)
+
+	require.NoError(t, authconfig.Save(&authconfig.Config{APIKey: "key"}))
+
+	info, err := os.Stat(nested)
+	require.NoError(t, err)
+	assert.True(t, info.IsDir())
+}
+
+func TestFilePermissions(t *testing.T) {
+	tmp := t.TempDir()
+	dir := filepath.Join(tmp, "newdir")
+	authconfig.SetDirFunc(func() (string, error) { return dir, nil })
+	t.Cleanup(authconfig.ResetDirFunc)
+
+	require.NoError(t, authconfig.Save(&authconfig.Config{APIKey: "key"}))
+
+	dirInfo, err := os.Stat(dir)
+	require.NoError(t, err)
+	assert.Equal(t, os.FileMode(0o700), dirInfo.Mode().Perm())
+
+	fileInfo, err := os.Stat(filepath.Join(dir, "config.yaml"))
+	require.NoError(t, err)
+	assert.Equal(t, os.FileMode(0o600), fileInfo.Mode().Perm())
+}

internal/cli/root.go cli/root.gointernal/cli/root.go renamed to cli/root.go

@@ -4,24 +4,31 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 
 	"github.com/charmbracelet/fang"
+	"github.com/duneanalytics/cli/authconfig"
+	"github.com/duneanalytics/cli/cmd/auth"
+	"github.com/duneanalytics/cli/cmd/execution"
 	"github.com/duneanalytics/cli/cmd/query"
+	"github.com/duneanalytics/cli/cmdutil"
 	"github.com/duneanalytics/duneapi-client-go/config"
 	"github.com/duneanalytics/duneapi-client-go/dune"
 	"github.com/spf13/cobra"
 )
 
-type clientKey struct{}
-
 var apiKeyFlag string
 
 var rootCmd = &cobra.Command{
 	Use:   "dune",
 	Short: "Dune CLI — interact with the Dune Analytics API",
 	Long: "A command-line interface for interacting with the Dune Analytics API.\n" +
 		"Manage queries, execute them, and retrieve results.",
-	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+	PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+		if cmd.Annotations["skipAuth"] == "true" {
+			return nil
+		}
+
 		var env *config.Env
 
 		switch {
@@ -31,28 +38,39 @@ var rootCmd = &cobra.Command{
 			var err error
 			env, err = config.FromEnvVars()
 			if err != nil {
-				return fmt.Errorf("missing API key: set DUNE_API_KEY or pass --api-key")
+				cfg, cfgErr := authconfig.Load()
+				if cfgErr != nil {
+					return fmt.Errorf("reading auth config: %w", cfgErr)
+				}
+				if cfg != nil {
+					key := strings.TrimSpace(cfg.APIKey)
+					if key == "" {
+						return fmt.Errorf("empty API key in config: run dune auth --api-key <key>")
+					}
+					env = config.FromAPIKey(key)
+				} else {
+					return fmt.Errorf("missing API key: set DUNE_API_KEY, pass --api-key, or run dune auth")
+				}
 			}
 		}
 
 		client := dune.NewDuneClient(env)
-		cmd.SetContext(context.WithValue(cmd.Context(), clientKey{}, dune.DuneClient(client)))
+		cmdutil.SetClient(cmd, client)
 		return nil
 	},
 }
 
 func init() {
 	rootCmd.PersistentFlags().StringVar(&apiKeyFlag, "api-key", "", "Dune API key (overrides DUNE_API_KEY env var)")
+	rootCmd.AddCommand(auth.NewAuthCmd())
 	rootCmd.AddCommand(query.NewQueryCmd())
-}
-
-// ClientFromCmd extracts the DuneClient stored in the command's context.
-func ClientFromCmd(cmd *cobra.Command) dune.DuneClient {
-	return cmd.Context().Value(clientKey{}).(dune.DuneClient)
+	rootCmd.AddCommand(execution.NewExecutionCmd())
 }
 
 // Execute runs the root command via Fang.
-func Execute() {
+func Execute(version, commit, date string) {
+	rootCmd.Version = fmt.Sprintf("%s (commit: %s, built: %s)", version, commit, date)
+
 	if err := fang.Execute(context.Background(), rootCmd); err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		os.Exit(1)