chore: use radix-cli as a module dependency

fix: imporve login flow

Author: FredrikMWold

applicationDashboard/applicationDashboard.go

@@ -12,8 +12,8 @@ func (m Model) Init() tea.Cmd {
 		m.applicationsTable.Init(),
 		m.pipelineTable.Init(),
 		m.enviromentTable.Init(),
-		commands.GetApplications,
-		m.spinner.Tick,
+		commands.CheckAuth(),
+		m.spinner.Tick, // spinner will be visible only when we choose to render it
 		getContext,
 	)
 }
@@ -22,6 +22,15 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	var cmds []tea.Cmd
 
 	switch msg := msg.(type) {
+	case commands.AuthWaiting:
+		// Show waiting for auth (no spinner), and trigger interactive login
+		m.hasAuthRedirect = true
+		return m, commands.LoginInteractive()
+
+	case commands.LoggedIn, commands.AuthOK:
+		// After login or when already authenticated, start loading applications
+		m.hasAuthRedirect = false
+		return m, commands.GetApplications
 
 	case tea.KeyMsg:
 		switch msg.String() {
@@ -54,7 +63,9 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 
 	case commands.Applications:
+		// Loaded apps → clear any implicit auth-waiting state
 		m.applications = msg
+		m.hasAuthRedirect = false
 
 	case Context:
 		m.context = string(msg)
@@ -105,6 +116,13 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 func (m Model) View() string {
+	// Before we get the first WindowSizeMsg, width/height can be 0; render a minimal view instead of blank.
+	if m.width == 0 || m.height == 0 {
+		if m.hasAuthRedirect {
+			return "Waiting for authentication"
+		}
+		return "Loading applications " + m.spinner.View()
+	}
 	if m.width <= 110 || m.height <= 25 {
 		return lipgloss.NewStyle().
 			Height(m.height).
@@ -120,6 +138,16 @@ func (m Model) View() string {
 
 	}
 	if len(m.applications) == 0 {
+		if m.hasAuthRedirect {
+			// During redirect, show text without spinner
+			return lipgloss.NewStyle().
+				Height(m.height).
+				Width(m.width).
+				AlignHorizontal(lipgloss.Center).
+				AlignVertical(lipgloss.Center).
+				Render("Waiting for authentication")
+		}
+		// Otherwise, show normal loading with spinner
 		return lipgloss.NewStyle().
 			Height(m.height).
 			Width(m.width).

applicationDashboard/commands.go

@@ -1,22 +1,17 @@
 package appllicationdashboard
 
 import (
-	"fmt"
-	"os/exec"
-	"regexp"
-
 	tea "github.com/charmbracelet/bubbletea"
+	radixconfig "github.com/equinor/radix-cli/pkg/config"
 )
 
 type Context string
 
 func getContext() tea.Msg {
-	result := exec.Command("rx", "get", "context")
-	regPattern := regexp.MustCompile(`'([^']*)'`)
-	output, err := result.CombinedOutput()
-	platform := regPattern.FindStringSubmatch(string(output))
-	if err != nil {
-		fmt.Println(err)
+	// Read from radix config (same as rx uses)
+	cfg, err := radixconfig.GetRadixConfig()
+	if err != nil || cfg == nil || cfg.CustomConfig == nil {
+		return Context("")
 	}
-	return Context(platform[1])
+	return Context(cfg.CustomConfig.Context)
 }

applicationDashboard/commands/commands.go

@@ -1,12 +1,15 @@
 package commands
 
 import (
-	"encoding/json"
+	"context"
 	"fmt"
-	"os/exec"
-	"strings"
+	"sort"
+	"time"
 
+	"github.com/FredrikMWold/radix-tui/internal/radix"
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/equinor/radix-cli/pkg/cache"
+	radixconfig "github.com/equinor/radix-cli/pkg/config"
 )
 
 type SelectedApplication string
@@ -19,18 +22,58 @@ func SelectApplication(application string) tea.Cmd {
 
 type Applications []string
 
+// AuthWaiting indicates we expect to perform interactive login.
+type AuthWaiting struct{}
+
+// AuthOK indicates cached provider/token is available; proceed to load apps.
+type AuthOK struct{}
+
+// CheckAuth decides if we should show auth-waiting or start loading immediately.
+func CheckAuth() tea.Cmd {
+	return func() tea.Msg {
+		authCacheFilename := fmt.Sprintf("%s/auth.json", radixconfig.RadixConfigDir)
+		global := cache.New(authCacheFilename, "global")
+		if prov, ok := global.GetItem("auth_provider_type"); !ok || prov != "msal_interactive" {
+			return AuthWaiting{}
+		}
+		// Check msal cache content under the interactive namespace
+		msal := cache.New(authCacheFilename, "msal_interactive")
+		if content, ok := msal.GetItem("msal"); !ok || len(content) == 0 {
+			return AuthWaiting{}
+		}
+		_ = time.Second // reserved for future TTL checks
+		return AuthOK{}
+	}
+}
+
+// LoginInteractive triggers an interactive login, then signals AuthOK.
+type LoggedIn struct{}
+
+func LoginInteractive() tea.Cmd {
+	return func() tea.Msg {
+		ctx := context.Background()
+		client, err := radix.New(false)
+		if err == nil {
+			_ = client.LoginInteractive(ctx)
+		}
+		return LoggedIn{}
+	}
+}
+
 func GetApplications() tea.Msg {
-	result := exec.Command("rx", "get", "application")
-	output, err := result.Output()
+	ctx := context.Background()
+	client, err := radix.New(false)
 	if err != nil {
 		fmt.Println(err)
+		return Applications{}
 	}
-	trimmed := strings.TrimSpace(string(output))
-	application_list := strings.Split(trimmed, "\n")
-	if strings.Contains(application_list[0], "login.microsoft") {
-		application_list = GetApplications().(Applications)
+	apps, err := client.ListApplications(ctx)
+	if err != nil {
+		fmt.Println(err)
+		return Applications{}
 	}
-	return Applications(application_list)
+	sort.Strings(apps)
+	return Applications(apps)
 }
 
 type Application struct {
@@ -56,16 +99,63 @@ type Environment struct {
 
 func GetApplicationData(application string) tea.Cmd {
 	return func() tea.Msg {
-		result := exec.Command("rx", "get", "application", "-a", application)
-		output, err := result.Output()
+		ctx := context.Background()
+		client, err := radix.New(false)
 		if err != nil {
 			fmt.Println(err)
+			return Application{}
 		}
-		var application Application
-		err = json.Unmarshal(output, &application)
+		app, err := client.GetApplication(ctx, application)
 		if err != nil {
 			fmt.Println(err)
+			return Application{}
+		}
+		// Map API model to local struct expected by views
+		var jobs []Job
+		if app.Jobs != nil {
+			for _, j := range app.Jobs {
+				if j == nil {
+					continue
+				}
+				jobs = append(jobs, Job{
+					Name:         stringDeref(j.Name),
+					TriggeredBy:  j.TriggeredBy,
+					Environments: j.Environments,
+					Pipeline:     j.Pipeline,
+					Status:       j.Status,
+					Created: func() string {
+						if j.Created != nil {
+							return j.Created.String()
+						}
+						return ""
+					}(),
+				})
+			}
 		}
-		return application
+		var envs []Environment
+		if app.Environments != nil {
+			for _, e := range app.Environments {
+				if e == nil {
+					continue
+				}
+				envs = append(envs, Environment{
+					BranchMapping: e.BranchMapping,
+					Name:          stringDeref(e.Name),
+					Status:        e.Status,
+				})
+			}
+		}
+		return Application{
+			Jobs:         jobs,
+			Environments: envs,
+			Name:         stringDeref(app.Name),
+		}
+	}
+}
+
+func stringDeref(p *string) string {
+	if p == nil {
+		return ""
 	}
+	return *p
 }

applicationDashboard/model.go

@@ -40,6 +40,7 @@ type Model struct {
 	height               int
 	width                int
 	applications         []string
+	hasAuthRedirect      bool
 }
 
 func New() Model {

applicationDashboard/pipelineForms/applyConfig/commands.go

@@ -1,17 +1,20 @@
 package applyconfig
 
 import (
+	"context"
 	"fmt"
-	"os/exec"
 
 	"github.com/FredrikMWold/radix-tui/applicationDashboard/commands"
+	"github.com/FredrikMWold/radix-tui/internal/radix"
 	tea "github.com/charmbracelet/bubbletea"
 )
 
 func ApplyConfig(application string) tea.Cmd {
 	return func() tea.Msg {
-		result := exec.Command("rx", "create", "pipeline-job", "apply-config", "-a", application)
-		_, err := result.Output()
+		client, err := radix.New(false)
+		if err == nil {
+			_, err = client.TriggerApplyConfig(context.Background(), application)
+		}
 		if err != nil {
 			fmt.Println(err)
 		}

applicationDashboard/pipelineForms/buildAndDeploy/commands.go

@@ -1,17 +1,20 @@
 package buildanddeploy
 
 import (
+	"context"
 	"fmt"
-	"os/exec"
 
 	"github.com/FredrikMWold/radix-tui/applicationDashboard/commands"
+	"github.com/FredrikMWold/radix-tui/internal/radix"
 	tea "github.com/charmbracelet/bubbletea"
 )
 
 func BuildAndDeploy(application string, branch string) tea.Cmd {
 	return func() tea.Msg {
-		result := exec.Command("rx", "create", "pipeline-job", "build-deploy", "-a", application, "-b", branch)
-		_, err := result.Output()
+		client, err := radix.New(false)
+		if err == nil {
+			_, err = client.TriggerBuildDeploy(context.Background(), application, branch, "")
+		}
 		if err != nil {
 			fmt.Println(err)
 		}

applicationDashboard/pipelineTable/model.go

@@ -3,6 +3,7 @@ package pipelinetable
 import (
 	"fmt"
 	"os/exec"
+	"runtime"
 	"time"
 
 	"github.com/FredrikMWold/radix-tui/applicationDashboard/commands"
@@ -48,5 +49,14 @@ func (m Model) openJobInBrowser() {
 	}
 	tableCursor := m.table.Cursor()
 	url := fmt.Sprintf("https://console.radix.equinor.com/applications/%s/jobs/view/%s", m.application.Name, m.application.Jobs[tableCursor].Name)
-	exec.Command("open", url).Start()
+	var cmd *exec.Cmd
+	switch runtime.GOOS {
+	case "darwin":
+		cmd = exec.Command("open", url)
+	case "windows":
+		cmd = exec.Command("rundll32", "url.dll,FileProtocolHandler", url)
+	default:
+		cmd = exec.Command("xdg-open", url)
+	}
+	_ = cmd.Start()
 }