feat(auth): add Coachless authentication controls

Add a reusable Coachless session service for status, login, logout, and auth bundle import/export.

Wire the service into the CLI, UI endpoints, and browser controls so users can manage stored credentials.

Author: controlado

cmd/lol-autobuild/app_adapters.go

@@ -132,6 +132,62 @@ func (c appUpdateChecker) Check(ctx context.Context) (app.UpdateCheckResult, err
 	return out, err
 }
 
+type appCoachlessAuthSession struct {
+	session *auth.CoachlessSession
+}
+
+func (s appCoachlessAuthSession) Status(ctx context.Context) app.CoachlessAuthState {
+	if s.session == nil {
+		return app.CoachlessAuthState{
+			Status: app.CoachlessAuthStatusMissing,
+			Plan:   app.CoachlessAuthPlanUnknown,
+		}
+	}
+
+	return appCoachlessAuthStateFromAuth(s.session.Status(ctx))
+}
+
+func (s appCoachlessAuthSession) Login(ctx context.Context) error {
+	return s.session.Login(ctx)
+}
+
+func (s appCoachlessAuthSession) Logout(ctx context.Context) error {
+	return s.session.Logout(ctx)
+}
+
+func appCoachlessAuthStateFromAuth(status auth.CoachlessSessionState) app.CoachlessAuthState {
+	return app.CoachlessAuthState{
+		Status:    appCoachlessAuthStatusFromAuth(status.Status),
+		Plan:      appCoachlessAuthPlanFromAuth(status.Plan),
+		ExpiresAt: status.ExpiresAt,
+		Message:   status.Message,
+	}
+}
+
+func appCoachlessAuthStatusFromAuth(status auth.CoachlessSessionStatus) app.CoachlessAuthStatus {
+	switch status {
+	case auth.CoachlessSessionStatusStored:
+		return app.CoachlessAuthStatusStored
+	case auth.CoachlessSessionStatusExpired:
+		return app.CoachlessAuthStatusExpired
+	case auth.CoachlessSessionStatusError:
+		return app.CoachlessAuthStatusError
+	default:
+		return app.CoachlessAuthStatusMissing
+	}
+}
+
+func appCoachlessAuthPlanFromAuth(plan auth.CoachlessPlan) app.CoachlessAuthPlan {
+	switch plan {
+	case auth.CoachlessPlanFree:
+		return app.CoachlessAuthPlanFree
+	case auth.CoachlessPlanPremium:
+		return app.CoachlessAuthPlanPremium
+	default:
+		return app.CoachlessAuthPlanUnknown
+	}
+}
+
 func appMessageFromErr(err error) app.UserMessage {
 	switch {
 	case err == nil:

cmd/lol-autobuild/app_adapters_test.go

@@ -143,6 +143,28 @@ func TestAppLCUStatusFromLCU(t *testing.T) {
 	}
 }
 
+func TestAppCoachlessAuthStateFromAuth(t *testing.T) {
+	t.Parallel()
+
+	expiresAt := time.Date(2026, time.May, 4, 12, 0, 0, 0, time.UTC)
+	got := appCoachlessAuthStateFromAuth(auth.CoachlessSessionState{
+		Status:    auth.CoachlessSessionStatusStored,
+		Plan:      auth.CoachlessPlanPremium,
+		ExpiresAt: &expiresAt,
+		Message:   "status",
+	})
+
+	if got.Status != app.CoachlessAuthStatusStored || got.Plan != app.CoachlessAuthPlanPremium {
+		t.Fatalf("converted status = %+v", got)
+	}
+	if got.ExpiresAt == nil || !got.ExpiresAt.Equal(expiresAt) {
+		t.Fatalf("converted ExpiresAt = %v, want %v", got.ExpiresAt, expiresAt)
+	}
+	if got.Message != "status" {
+		t.Fatalf("converted Message = %q, want status", got.Message)
+	}
+}
+
 type stubUpdateSource struct {
 	currentVersion string
 	result         update.Result

cmd/lol-autobuild/auth_cmd.go

@@ -0,0 +1,211 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/controlado/lol-autobuild/internal/auth"
+	"github.com/controlado/lol-autobuild/internal/config"
+)
+
+type authCommandSession interface {
+	Status(context.Context) auth.CoachlessSessionState
+	Login(context.Context) error
+	Logout(context.Context) error
+	Export(context.Context) (string, error)
+	Import(context.Context, string) error
+}
+
+type authCommandSessionFactory func(config.Config) authCommandSession
+
+type authStatusOutput struct {
+	Status    auth.CoachlessSessionStatus `json:"status"`
+	Plan      auth.CoachlessPlan          `json:"plan"`
+	ExpiresAt *time.Time                  `json:"expires_at,omitempty"`
+	Message   string                      `json:"message,omitempty"`
+}
+
+func authCmd() *cobra.Command {
+	return newAuthCmd(func(cfg config.Config) authCommandSession { return buildCoachlessAuthSession(cfg) })
+}
+
+func newAuthCmd(sessionFactory authCommandSessionFactory) *cobra.Command {
+	var configPath string
+
+	cmd := &cobra.Command{
+		Use:   "auth",
+		Short: "Manage Coachless authentication",
+		Args:  cobra.NoArgs,
+	}
+	cmd.PersistentFlags().StringVar(&configPath, "config", defaultConfigPath, "Path to YAML configuration file")
+
+	cmd.AddCommand(authStatusCmd(&configPath, sessionFactory))
+	cmd.AddCommand(authLoginCmd(&configPath, sessionFactory))
+	cmd.AddCommand(authLogoutCmd(&configPath, sessionFactory))
+	cmd.AddCommand(authExportCmd(&configPath, sessionFactory))
+	cmd.AddCommand(authImportCmd(&configPath, sessionFactory))
+
+	return cmd
+}
+
+func authStatusCmd(configPath *string, sessionFactory authCommandSessionFactory) *cobra.Command {
+	return &cobra.Command{
+		Use:   "status",
+		Short: "Show Coachless authentication status",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			session, err := loadAuthCommandSession(*configPath, sessionFactory)
+			if err != nil {
+				return err
+			}
+
+			status := session.Status(cmd.Context())
+			out := authStatusOutput{
+				Status:    status.Status,
+				Plan:      status.Plan,
+				ExpiresAt: status.ExpiresAt,
+				Message:   status.Message,
+			}
+
+			encoded, err := json.MarshalIndent(out, "", "  ")
+			if err != nil {
+				return fmt.Errorf("encode auth status: %w", err)
+			}
+
+			_, err = fmt.Fprintln(cmd.OutOrStdout(), string(encoded))
+			return err
+		},
+	}
+}
+
+func authLoginCmd(configPath *string, sessionFactory authCommandSessionFactory) *cobra.Command {
+	return &cobra.Command{
+		Use:   "login",
+		Short: "Sign in to Coachless",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			session, err := loadAuthCommandSession(*configPath, sessionFactory)
+			if err != nil {
+				return err
+			}
+			if err := session.Login(cmd.Context()); err != nil {
+				return err
+			}
+
+			_, err = fmt.Fprintln(cmd.OutOrStdout(), "Coachless authentication saved.")
+			return err
+		},
+	}
+}
+
+func authLogoutCmd(configPath *string, sessionFactory authCommandSessionFactory) *cobra.Command {
+	return &cobra.Command{
+		Use:   "logout",
+		Short: "Sign out of Coachless",
+		Args:  cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			session, err := loadAuthCommandSession(*configPath, sessionFactory)
+			if err != nil {
+				return err
+			}
+			if err := session.Logout(cmd.Context()); err != nil {
+				return err
+			}
+
+			_, err = fmt.Fprintln(cmd.OutOrStdout(), "Coachless authentication cleared.")
+			return err
+		},
+	}
+}
+
+func authExportCmd(configPath *string, sessionFactory authCommandSessionFactory) *cobra.Command {
+	return &cobra.Command{
+		Use:    "export",
+		Short:  "Export Coachless authentication",
+		Hidden: true,
+		Args:   cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			session, err := loadAuthCommandSession(*configPath, sessionFactory)
+			if err != nil {
+				return err
+			}
+
+			bundle, err := session.Export(cmd.Context())
+			if err != nil {
+				return err
+			}
+
+			if _, err := fmt.Fprintln(cmd.ErrOrStderr(), "Warning: exported Coachless authentication contains secret tokens. Keep it private."); err != nil {
+				return err
+			}
+			_, err = fmt.Fprintln(cmd.OutOrStdout(), bundle)
+			return err
+		},
+	}
+}
+
+func authImportCmd(configPath *string, sessionFactory authCommandSessionFactory) *cobra.Command {
+	var filePath string
+
+	cmd := &cobra.Command{
+		Use:    "import",
+		Short:  "Import Coachless authentication",
+		Hidden: true,
+		Args:   cobra.NoArgs,
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			session, err := loadAuthCommandSession(*configPath, sessionFactory)
+			if err != nil {
+				return err
+			}
+
+			raw, err := readAuthImportBundle(cmd, filePath)
+			if err != nil {
+				return err
+			}
+			if err := session.Import(cmd.Context(), raw); err != nil {
+				return err
+			}
+
+			_, err = fmt.Fprintln(cmd.OutOrStdout(), "Coachless authentication imported.")
+			return err
+		},
+	}
+	cmd.Flags().StringVar(&filePath, "file", "", "Path to Coachless authentication bundle")
+	return cmd
+}
+
+func loadAuthCommandSession(configPath string, sessionFactory authCommandSessionFactory) (authCommandSession, error) {
+	cfg, err := loadConfigAndLogging(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	session := sessionFactory(cfg)
+	if session == nil {
+		return nil, fmt.Errorf("coachless authentication is unavailable")
+	}
+	return session, nil
+}
+
+func readAuthImportBundle(cmd *cobra.Command, filePath string) (string, error) {
+	if strings.TrimSpace(filePath) != "" {
+		raw, err := os.ReadFile(filePath)
+		if err != nil {
+			return "", fmt.Errorf("read auth bundle file: %w", err)
+		}
+		return string(raw), nil
+	}
+
+	raw, err := io.ReadAll(cmd.InOrStdin())
+	if err != nil {
+		return "", fmt.Errorf("read auth bundle stdin: %w", err)
+	}
+	return string(raw), nil
+}