@owdproject/cli 0.0.3 → 0.2.0

package/go/tui/tui.go

@@ -0,0 +1,869 @@
+package tui
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"owd-cli/bridge"
+
+	"github.com/charmbracelet/bubbles/textinput"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func NewModel(root string) TuiModel {
+	return TuiModel{
+		workspaceRoot:    root,
+		activeTab:        1, // Default to Apps (index 1), Internal (index 0) is secret
+		loading:          true,
+		statusMsg:        "Initializing OWD Control Panel…",
+		logLines:         []string{},
+		memHistory:       []int{},
+		gitChangesMap:    make(map[string]GitChanges),
+		updatesMap:       make(map[string]UpdateInfo),
+		localGitDirs:     make(map[string]bool),
+		settingsSel:      0,
+		termWidth:        160,
+		termHeight:       40,
+		lastInstallMethod: "npm",
+		logTailerStarted:  false,
+		pendingPackages:  make(map[string]bool),
+		pendingTheme:     nil,
+		workQueue:        NewWorkQueue(),
+		enginePhase:      PhaseIdle,
+		runtime: &RuntimeState{
+			msgChan:      make(chan tea.Msg, 500),
+			engineResume: make(chan string, 1),
+		},
+		startServerAfterSetup: false,
+		setupStep:             0,
+		setupTotalSteps:       0,
+		setupLabel:            "",
+		activeTask:            TaskNone,
+		workspaceBranch:       "—",
+		workspaceChanges:      "clean",
+		clientStars:           -1,
+	}
+}
+
+func (m *TuiModel) listenToChannel() tea.Cmd {
+	return func() tea.Msg {
+		return <-m.runtime.msgChan
+	}
+}
+
+func (m *TuiModel) Init() tea.Cmd {
+	return tea.Batch(
+		m.loadContextCmd(),
+		m.loadCatalogCmd(false),
+		m.checkServerStatusCmd(),
+		m.updateWorkspaceGitStatusCmd(),
+		m.listenToChannel(),
+		tickCmd(),
+		m.fetchClientStarsCmd(),
+	)
+}
+
+// ─────────────────────────────────────────────
+// Commands
+// ─────────────────────────────────────────────
+
+func tickCmd() tea.Cmd {
+	return tea.Tick(150*time.Millisecond, func(t time.Time) tea.Msg {
+		return tickMsg(t)
+	})
+}
+
+func memSampleCmd() tea.Cmd {
+	return func() tea.Msg {
+		var ms runtime.MemStats
+		runtime.ReadMemStats(&ms)
+		mb := int(ms.Sys / 1024 / 1024)
+		return memTickMsg{MemMB: mb}
+	}
+}
+
+func (m *TuiModel) loadContextCmd() tea.Cmd {
+	return func() tea.Msg {
+		ctx, err := bridge.ReadWorkspaceContext(m.workspaceRoot)
+		return contextLoadedMsg{Ctx: ctx, Err: err}
+	}
+}
+
+func (m *TuiModel) loadCatalogCmd(force bool) tea.Cmd {
+	return func() tea.Msg {
+		cat, err := bridge.ReadCatalog(m.workspaceRoot, force)
+		return catalogLoadedMsg{Cat: cat, Err: err}
+	}
+}
+
+type clientStarsMsg int
+
+func (m *TuiModel) fetchClientStarsCmd() tea.Cmd {
+	return func() tea.Msg {
+		client := &http.Client{Timeout: 3 * time.Second}
+		req, err := http.NewRequest("GET", "https://api.github.com/repos/owdproject/client", nil)
+		if err != nil {
+			return clientStarsMsg(-1)
+		}
+		req.Header.Set("User-Agent", "owd-cli")
+		resp, err := client.Do(req)
+		if err != nil {
+			return clientStarsMsg(-1)
+		}
+		defer resp.Body.Close()
+
+		var res map[string]interface{}
+		if err := json.NewDecoder(resp.Body).Decode(&res); err == nil {
+			if starsVal, ok := res["stargazers_count"]; ok {
+				if starsFloat, ok := starsVal.(float64); ok {
+					return clientStarsMsg(int(starsFloat))
+				}
+			}
+		}
+		return clientStarsMsg(-1)
+	}
+}
+
+func (m *TuiModel) checkServerStatusCmd() tea.Cmd {
+	return func() tea.Msg {
+		if m.ctx == nil {
+			return serverStatusMsg{Running: false}
+		}
+
+		port := m.ctx.Settings.DevPort
+		if port == 0 {
+			port = 3000
+		}
+
+		open := isPortOpen(port)
+		if !open {
+			pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
+			_ = os.Remove(pidPath)
+			return serverStatusMsg{Running: false}
+		}
+
+		pid := findProcessPID(port)
+		if pid > 0 {
+			pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
+			_ = os.WriteFile(pidPath, []byte(fmt.Sprintf("%d", pid)), 0644)
+		}
+
+		return serverStatusMsg{Running: true}
+	}
+}
+
+func (m *TuiModel) updateWorkspaceGitStatusCmd() tea.Cmd {
+	return func() tea.Msg {
+		branch := gitBranch(m.workspaceRoot)
+		changes := gitChanges(m.workspaceRoot)
+		return workspaceGitStatusMsg{Branch: branch, Changes: changes}
+	}
+}
+
+func (m *TuiModel) hasPendingChanges() bool {
+	if len(m.pendingPackages) > 0 {
+		return true
+	}
+	if m.pendingTheme != nil {
+		if m.ctx != nil && m.ctx.Config.Theme != nil {
+			return *m.ctx.Config.Theme != *m.pendingTheme
+		}
+		return true
+	}
+	return false
+}
+
+func (m *TuiModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+
+	case tea.MouseMsg:
+		if msg.Action == tea.MouseActionRelease && msg.Button == tea.MouseButtonLeft {
+			if m.isClearLogsClick(msg) {
+				m.logLines = []string{}
+				m.statusMsg = "Logs cleared."
+				return m, nil
+			}
+			if msg.Y == 10 {
+				if msg.X <= 13 {
+					m.activeTab, m.selectedIndex, m.scrollOffset = 0, 0, 0
+					return m, nil
+				}
+				if msg.X >= 14 && msg.X <= 22 {
+					m.activeTab, m.selectedIndex, m.scrollOffset = 1, 0, 0
+					return m, nil
+				}
+				if msg.X >= 23 && msg.X <= 34 {
+					m.activeTab, m.selectedIndex, m.scrollOffset = 2, 0, 0
+					return m, nil
+				}
+				if msg.X >= 35 {
+					m.activeTab, m.selectedIndex, m.scrollOffset = 3, 0, 0
+					return m, nil
+				}
+			}
+		}
+		return m, nil
+
+	case tea.WindowSizeMsg:
+		m.termWidth = msg.Width
+		m.termHeight = msg.Height
+		return m, nil
+
+	case clientStarsMsg:
+		if int(msg) >= 0 {
+			m.clientStars = int(msg)
+		}
+		return m, nil
+
+	case tickMsg:
+		m.tickCount++
+		if m.tickCount%4 == 0 {
+			m.blink = !m.blink
+		}
+
+		var cmds []tea.Cmd
+		cmds = append(cmds, tickCmd())
+
+		// Every ~1.5s: sample memory + check server status
+		if m.tickCount%10 == 0 {
+			var mb int
+			if m.ctx != nil {
+				pidPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.pid")
+				if data, err := os.ReadFile(pidPath); err == nil {
+					var pid int
+					if _, err := fmt.Sscanf(strings.TrimSpace(string(data)), "%d", &pid); err == nil {
+						mb = getProcessMemoryMB(pid)
+					}
+				}
+			}
+			m.memHistory = append(m.memHistory, mb)
+			if len(m.memHistory) > 30 {
+				m.memHistory = m.memHistory[1:]
+			}
+			if m.ctx != nil {
+				cmds = append(cmds, m.checkServerStatusCmd())
+			}
+		}
+
+		// Every ~15s: fast local git status check (no network)
+		if m.tickCount%100 == 0 && !m.loading && m.activeTask == TaskNone && !m.checkingUpdates {
+			m.checkingUpdates = true
+			cmds = append(cmds, m.checkLocalChangesCmd(), m.updateWorkspaceGitStatusCmd())
+		}
+
+		// Every ~5min: slow remote check (git behind without fetch + npm versions)
+		if m.tickCount%2000 == 0 && !m.loading && m.activeTask == TaskNone {
+			cmds = append(cmds, m.checkRemoteUpdatesCmd())
+		}
+
+		return m, tea.Batch(cmds...)
+
+	case tea.KeyMsg:
+		promptToShow := m.activePrompt
+		if (m.activeTask == TaskSetup || m.activeTask == TaskWipe) &&
+			m.activePrompt != PromptResolveDependency &&
+			(promptToShow == PromptNone || promptToShow == PromptUninstallConfirm || promptToShow == PromptInstallMethod || promptToShow == PromptWipeWorkspaceConfirm) {
+			promptToShow = PromptSetupProgress
+		}
+		if promptToShow != PromptNone {
+			return m.handlePromptKeys(msg)
+		}
+		switch msg.String() {
+		case "q", "ctrl+c":
+			return m, tea.Quit
+		case "0":
+			m.activeTab, m.selectedIndex, m.scrollOffset = 0, 0, 0
+		case "1":
+			m.activeTab, m.selectedIndex, m.scrollOffset = 1, 0, 0
+		case "2":
+			m.activeTab, m.selectedIndex, m.scrollOffset = 2, 0, 0
+		case "3":
+			m.activeTab, m.selectedIndex, m.scrollOffset = 3, 0, 0
+		case "left":
+			if m.activeTab == 0 {
+				m.activeTab = 3
+			} else {
+				m.activeTab--
+			}
+			m.selectedIndex, m.scrollOffset = 0, 0
+		case "right":
+			if m.activeTab == 3 {
+				m.activeTab = 1
+			} else {
+				m.activeTab++
+			}
+			m.selectedIndex, m.scrollOffset = 0, 0
+		case "up", "k":
+			if m.selectedIndex > 0 {
+				m.selectedIndex--
+				if m.selectedIndex < m.scrollOffset {
+					m.scrollOffset = m.selectedIndex
+				}
+			}
+		case "down", "j":
+			items := m.getActiveItems()
+			if m.selectedIndex < len(items)-1 {
+				m.selectedIndex++
+			}
+		case "r":
+			m.loading = true
+			m.statusMsg = "Refreshing package catalog…"
+			return m, m.loadCatalogCmd(true)
+		case "s":
+			if m.hasPendingChanges() {
+				return m, m.startWizard(WizardSave)
+			}
+			cmd := m.startWizard(WizardStartupCheck)
+			if cmd != nil {
+				return m, cmd
+			}
+		case "d":
+			if !m.serverRunning && m.activeTask == TaskNone {
+				if m.hasPendingChanges() {
+					return m, m.startWizard(WizardSaveAndServe)
+				}
+				cmd := m.startWizard(WizardStartupCheck)
+				if cmd != nil {
+					m.startServerAfterSetup = true
+					return m, cmd
+				}
+
+				m.statusMsg = "Starting dev server…"
+				m.activeTask = TaskServe
+				m.RunServeTask()
+			}
+		case "x":
+			if m.serverRunning {
+				m.statusMsg = "Stopping dev server…"
+				m.activeTask = TaskServe
+				m.StopServeTask()
+			}
+		case "c":
+			items := m.getActiveItems()
+			if len(items) > 0 && m.selectedIndex < len(items) {
+				pkg := items[m.selectedIndex]
+				m.promptPkg = &pkg
+				m.loadPackageDetails(&pkg)
+				m.activePrompt = PromptManagePackage
+				m.promptSel = 0
+			}
+		case "enter", " ":
+			items := m.getActiveItems()
+			if len(items) > 0 && m.selectedIndex < len(items) {
+				pkg := items[m.selectedIndex]
+				if m.activeTab == 3 { // Themes (radiobox)
+					current := activeThemeName(m.ctx, m.pendingTheme)
+					if current == pkg.Name && m.pendingTheme != nil {
+						m.pendingTheme = nil
+					} else if current != pkg.Name {
+						themeName := pkg.Name
+						m.pendingTheme = &themeName
+					}
+				} else { // Apps or Modules (checkbox)
+					if pkg.Installed {
+						if _, exists := m.pendingPackages[pkg.Name]; exists {
+							delete(m.pendingPackages, pkg.Name)
+						} else {
+							m.pendingPackages[pkg.Name] = false
+						}
+					} else {
+						if _, exists := m.pendingPackages[pkg.Name]; exists {
+							delete(m.pendingPackages, pkg.Name)
+						} else {
+							m.pendingPackages[pkg.Name] = true
+						}
+					}
+				}
+			}
+		case "u":
+			items := m.getActiveItems()
+			if len(items) > 0 && m.selectedIndex < len(items) {
+				pkg := items[m.selectedIndex]
+				if pkg.Installed && m.activeTask == TaskNone {
+					m.activeTask = TaskSetup
+					m.statusMsg = fmt.Sprintf("Updating %s…", pkg.ShortName)
+					m.RunUpdatePackageTask(pkg.Name, pkg.ShortName, pkg.Kind, pkg.LocalSource)
+				}
+			}
+		case "g":
+			if m.ctx != nil {
+				m.settingsInstallMode = m.ctx.Settings.InstallMode
+				m.settingsCatalogSort = m.ctx.Settings.CatalogSort
+				m.settingsSel = 0
+				m.activePrompt = PromptSettings
+
+				// Initialize text inputs
+				tiUser := textinput.New()
+				tiUser.Placeholder = "github_user"
+				tiUser.CharLimit = 64
+				tiUser.Width = 30
+				if m.ctx.Settings.GithubUser != nil {
+					tiUser.SetValue(*m.ctx.Settings.GithubUser)
+				}
+				m.settingsUserInput = tiUser
+
+				tiOrgs := textinput.New()
+				tiOrgs.Placeholder = "org1, org2"
+				tiOrgs.CharLimit = 256
+				tiOrgs.Width = 40
+				if len(m.ctx.Settings.GithubOrgs) > 0 {
+					tiOrgs.SetValue(strings.Join(m.ctx.Settings.GithubOrgs, ", "))
+				} else {
+					tiOrgs.SetValue("owdproject, atproto-os")
+				}
+				m.settingsOrgsInput = tiOrgs
+
+				m.updateSettingsFocus()
+			}
+		case "n":
+			m.ExitCode = 10
+			return m, tea.Quit
+		}
+		return m, nil
+
+	case contextLoadedMsg:
+		m.loading = false
+		if msg.Err != nil {
+			m.err = msg.Err
+			m.statusMsg = fmt.Sprintf("Error loading workspace: %v", msg.Err)
+		} else {
+			m.ctx = msg.Ctx
+			m.statusMsg = "Workspace loaded."
+
+			if !m.logTailerStarted && m.ctx != nil {
+				m.logTailerStarted = true
+				logPath := filepath.Join(m.ctx.Paths.MetaDir, "dev.log")
+				m.StartLogTailer(logPath)
+			}
+
+			return m, m.checkServerStatusCmd()
+		}
+
+	case catalogLoadedMsg:
+		m.loading = false
+		if msg.Err != nil {
+			m.err = msg.Err
+			m.statusMsg = fmt.Sprintf("Error loading catalog: %v", msg.Err)
+		} else {
+			m.catalog = msg.Cat
+			m.statusMsg = fmt.Sprintf("Catalog loaded (%s).", msg.Cat.CacheAge)
+
+			// Run fast local check immediately; schedule remote check too
+			m.checkingUpdates = true
+			return m, tea.Batch(m.checkLocalChangesCmd(), m.checkRemoteUpdatesCmd())
+		}
+
+	case localChangesMsg:
+		m.gitChangesMap = msg.GitChanges
+		m.localGitDirs = msg.LocalGitDirs
+		m.checkingUpdates = false
+		m.loading = false
+
+	case remoteUpdatesMsg:
+		m.updatesMap = msg.Updates
+		if msg.Err == nil {
+			count := 0
+			for _, up := range msg.Updates {
+				if up.LocalGit || up.Npm {
+					count++
+				}
+			}
+			if count > 0 {
+				m.statusMsg = fmt.Sprintf("%d update(s) available.", count)
+			}
+		}
+
+	case setupProgressMsg:
+		m.setupStep = msg.Step
+		m.setupTotalSteps = msg.Total
+		m.setupLabel = msg.Label
+		return m, m.listenToChannel()
+
+	case engineQueueUpdatedMsg:
+		q := msg.Queue
+		m.workQueue = &q
+		completed, total := q.Progress()
+		m.setupStep = completed
+		m.setupTotalSteps = total
+		return m, m.listenToChannel()
+
+	case enginePhaseMsg:
+		m.enginePhase = msg.Phase
+		return m, m.listenToChannel()
+
+	case engineNeedsPromptMsg:
+		m.promptItem = &msg.Item
+		m.promptPkg = &msg.Item.Entry
+		m.activePrompt = PromptResolveDependency
+		m.promptSel = 0
+		m.statusMsg = fmt.Sprintf("Resolve dependency: %s", msg.Item.ShortName)
+		return m, m.listenToChannel()
+
+	case logLineMsg:
+		line := string(msg)
+		if strings.Contains(line, "█") || strings.Contains(line, "▄") || strings.Contains(line, "▀") {
+			return m, m.listenToChannel()
+		}
+		if strings.Contains(line, "Local:") || strings.Contains(line, "Network:") || strings.Contains(line, "expose") || strings.Contains(line, "➜") {
+			return m, m.listenToChannel()
+		}
+		m.addLog(line)
+		return m, m.listenToChannel()
+
+	case clearLogsMsg:
+		m.logLines = []string{}
+		return m, m.listenToChannel()
+
+	case taskFinishedMsg:
+		m.activeTask = TaskNone
+		m.enginePhase = PhaseIdle
+		m.activePrompt = PromptNone
+		m.promptItem = nil
+		if msg.Success {
+			m.statusMsg = "Task completed."
+			m.addLog("✓ Wizard completed successfully")
+			if m.serverRunning {
+				m.addLog("ℹ desktop.config.ts updated — Nuxt restarts automatically (see dev server log)")
+			}
+
+			if m.startServerAfterSetup {
+				m.startServerAfterSetup = false
+				m.statusMsg = "Starting dev server…"
+				m.addLog("ℹ Starting development server…")
+				m.activeTask = TaskServe
+				m.RunServeTask()
+			}
+		} else {
+			m.statusMsg = fmt.Sprintf("Task failed: %v", msg.Err)
+			m.addLog(fmt.Sprintf("✖ Wizard failed: %v", msg.Err))
+			m.startServerAfterSetup = false
+		}
+		return m, tea.Batch(m.loadContextCmd(), m.loadCatalogCmd(false), m.updateWorkspaceGitStatusCmd(), m.listenToChannel())
+
+	case serverStatusMsg:
+		m.serverRunning = msg.Running
+		if m.activeTask == TaskServe {
+			m.activeTask = TaskNone
+		}
+		if !msg.Running {
+			m.statusMsg = "Dev server stopped."
+		} else {
+			m.statusMsg = "Dev server running."
+		}
+		return m, m.listenToChannel()
+	case workspaceGitStatusMsg:
+		m.workspaceBranch = msg.Branch
+		m.workspaceChanges = msg.Changes
+		return m, nil
+	}
+
+	return m, nil
+}
+
+func (m *TuiModel) addLog(line string) {
+	// Split on embedded newlines — Nuxt can emit multi-line chunks as a single string.
+	// If we store them unsplit, the panel renders 1 counted line but N terminal lines → layout breaks.
+	line = strings.ReplaceAll(line, "\r\n", "\n")
+	sublines := strings.Split(line, "\n")
+	for _, sl := range sublines {
+		sl = strings.TrimRight(sl, "\r")
+		if sl == "" {
+			continue
+		}
+		m.logLines = append(m.logLines, sl)
+	}
+	if len(m.logLines) > 200 {
+		m.logLines = m.logLines[len(m.logLines)-200:]
+	}
+}
+
+
+// checkLocalChangesCmd runs a fast local-only git status check for every catalog entry.
+// No network activity — only reads the local working tree.
+// Runs every ~15s. Also detects which packages have their own .git folder.
+func (m *TuiModel) checkLocalChangesCmd() tea.Cmd {
+	return func() tea.Msg {
+		gitChangesMap := make(map[string]GitChanges)
+		localGitDirs := make(map[string]bool)
+
+		if m.catalog == nil {
+			return localChangesMsg{GitChanges: gitChangesMap, LocalGitDirs: localGitDirs}
+		}
+
+		for _, entry := range m.catalog.Entries {
+			short := entry.ShortName
+			var kindDir string
+			switch entry.Kind {
+			case "app":
+				kindDir = "apps"
+			case "module":
+				kindDir = "packages"
+			case "theme":
+				kindDir = "themes"
+			}
+			if kindDir == "" {
+				continue
+			}
+
+			pkgPath := filepath.Join(m.workspaceRoot, kindDir, short)
+			gitDir := filepath.Join(pkgPath, ".git")
+
+			if _, err := os.Stat(gitDir); err == nil {
+				// Package has its own .git repo
+				localGitDirs[short] = true
+				added, modified, deleted, err := runGitStatus(pkgPath)
+				if err == nil && (added > 0 || modified > 0 || deleted > 0) {
+					gitChangesMap[short] = GitChanges{Added: added, Modified: modified, Deleted: deleted}
+				}
+			} else {
+				// Fallback: check monorepo git for this subdirectory
+				parentGitDir := filepath.Join(m.workspaceRoot, ".git")
+				if _, err := os.Stat(parentGitDir); err == nil {
+					relPath := filepath.Join(kindDir, short)
+					added, modified, deleted, err := runGitStatusForSubdir(m.workspaceRoot, relPath)
+					if err == nil && (added > 0 || modified > 0 || deleted > 0) {
+						gitChangesMap[short] = GitChanges{Added: added, Modified: modified, Deleted: deleted}
+					}
+				}
+			}
+		}
+
+		return localChangesMsg{GitChanges: gitChangesMap, LocalGitDirs: localGitDirs}
+	}
+}
+
+// checkRemoteUpdatesCmd runs the slow network-dependent checks:
+// - git behind count (uses cached remote refs, NO git fetch)
+// - npm latest version check
+// Runs every ~5 minutes.
+func (m *TuiModel) checkRemoteUpdatesCmd() tea.Cmd {
+	return func() tea.Msg {
+		updatesMap := make(map[string]UpdateInfo)
+
+		if m.catalog == nil {
+			return remoteUpdatesMsg{Updates: updatesMap}
+		}
+
+		type result struct {
+			shortName string
+			update    *UpdateInfo
+			err       error
+		}
+
+		resultsChan := make(chan result, len(m.catalog.Entries))
+		sem := make(chan struct{}, 5) // modest concurrency — these are network ops
+
+		for _, e := range m.catalog.Entries {
+			sem <- struct{}{}
+			go func(entry bridge.CatalogEntry) {
+				defer func() { <-sem }()
+
+				res := result{shortName: entry.ShortName}
+
+				short := entry.ShortName
+				var kindDir string
+				switch entry.Kind {
+				case "app":
+					kindDir = "apps"
+				case "module":
+					kindDir = "packages"
+				case "theme":
+					kindDir = "themes"
+				}
+
+				// 1. Git behind check (NO fetch — uses cached remote refs)
+				if kindDir != "" {
+					pkgPath := filepath.Join(m.workspaceRoot, kindDir, short)
+					gitDir := filepath.Join(pkgPath, ".git")
+					if _, err := os.Stat(gitDir); err == nil {
+						behind, err := runGitBehindCheckNoFetch(pkgPath)
+						if err == nil && behind > 0 {
+							res.update = &UpdateInfo{LocalGit: true, BehindCount: behind}
+						}
+					}
+				}
+
+				// 2. NPM latest version check
+				if entry.Installed && !entry.LocalSource {
+					localVer := getLocalVersion(m.workspaceRoot, entry)
+					if localVer != "" {
+						latestVer, err := fetchLatestNpmVersion(entry.Name)
+						if err != nil {
+							res.err = err
+						} else if semverCompare(localVer, latestVer) < 0 {
+							res.update = &UpdateInfo{Npm: true}
+						}
+					}
+				}
+
+				resultsChan <- res
+			}(e)
+		}
+
+		var checkErr error
+		for i := 0; i < len(m.catalog.Entries); i++ {
+			res := <-resultsChan
+			if res.update != nil {
+				updatesMap[res.shortName] = *res.update
+			}
+			if res.err != nil && checkErr == nil {
+				checkErr = res.err
+			}
+		}
+
+		return remoteUpdatesMsg{Updates: updatesMap, Err: checkErr}
+	}
+}
+
+func getLocalVersion(workspaceRoot string, entry bridge.CatalogEntry) string {
+	short := entry.ShortName
+	kindDir := ""
+	switch entry.Kind {
+	case "app":
+		kindDir = "apps"
+	case "module":
+		kindDir = "packages"
+	case "theme":
+		kindDir = "themes"
+	}
+	var paths []string
+	if kindDir != "" {
+		paths = append(paths, filepath.Join(workspaceRoot, kindDir, short, "package.json"))
+	}
+	paths = append(paths, filepath.Join(workspaceRoot, "node_modules", entry.Name, "package.json"))
+
+	for _, p := range paths {
+		if data, err := os.ReadFile(p); err == nil {
+			var pkg struct {
+				Version string `json:"version"`
+			}
+			if err := json.Unmarshal(data, &pkg); err == nil {
+				return pkg.Version
+			}
+		}
+	}
+	return ""
+}
+
+func semverCompare(v1, v2 string) int {
+	v1 = strings.TrimPrefix(v1, "v")
+	v2 = strings.TrimPrefix(v2, "v")
+	parts1 := strings.Split(v1, ".")
+	parts2 := strings.Split(v2, ".")
+	for i := 0; i < len(parts1) && i < len(parts2); i++ {
+		var n1, n2 int
+		fmt.Sscanf(parts1[i], "%d", &n1)
+		fmt.Sscanf(parts2[i], "%d", &n2)
+		if n1 != n2 {
+			return n1 - n2
+		}
+	}
+	return len(parts1) - len(parts2)
+}
+
+func (m *TuiModel) loadPackageDetails(pkg *bridge.CatalogEntry) {
+	m.promptPkgDeps = []string{}
+	m.promptPkgHasPrimevue = false
+	m.promptPkgHasTailwind = false
+
+	if pkg == nil {
+		return
+	}
+
+	short := pkg.ShortName
+	var pathsToCheck []string
+
+	kindDir := ""
+	switch pkg.Kind {
+	case "app":
+		kindDir = "apps"
+	case "module":
+		kindDir = "packages"
+	case "theme":
+		kindDir = "themes"
+	}
+
+	if kindDir != "" {
+		pathsToCheck = append(pathsToCheck, filepath.Join(m.workspaceRoot, kindDir, short, "package.json"))
+	}
+	pathsToCheck = append(pathsToCheck, filepath.Join(m.workspaceRoot, "node_modules", "@owdproject", short, "package.json"))
+
+	var data []byte
+	var err error
+	for _, p := range pathsToCheck {
+		data, err = os.ReadFile(p)
+		if err == nil {
+			break
+		}
+	}
+
+	if err != nil {
+		return
+	}
+
+	var pkgJson struct {
+		Dependencies    map[string]string `json:"dependencies"`
+		DevDependencies map[string]string `json:"devDependencies"`
+	}
+
+	if err := json.Unmarshal(data, &pkgJson); err == nil {
+		checkDep := func(name string) {
+			if strings.HasPrefix(name, "@owdproject/") {
+				for _, d := range m.promptPkgDeps {
+					if d == name {
+						return
+					}
+				}
+				m.promptPkgDeps = append(m.promptPkgDeps, name)
+			}
+			if name == "@owdproject/kit-primevue" {
+				m.promptPkgHasPrimevue = true
+			}
+			if name == "@owdproject/kit-tailwind" || name == "tailwindcss" {
+				m.promptPkgHasTailwind = true
+			}
+		}
+		for name := range pkgJson.Dependencies {
+			checkDep(name)
+		}
+		for name := range pkgJson.DevDependencies {
+			checkDep(name)
+		}
+	}
+}
+
+func (m *TuiModel) isClearLogsClick(msg tea.MouseMsg) bool {
+	if msg.Y != 0 {
+		return false
+	}
+
+	w := m.termWidth
+	if w < 120 {
+		return false
+	}
+
+	leftW := w * 40 / 100
+	midW := w * 28 / 100
+	catW := leftW + midW
+
+	panelStartX := catW - 1
+
+	rightPanelTitle := "Logs"
+	if m.activePrompt == PromptResolveDependency {
+		rightPanelTitle = "Wizard Setup"
+	} else if m.activeTask == TaskSetup || m.activeTask == TaskWipe {
+		rightPanelTitle = "Setup"
+	}
+
+	prefixLen := len(rightPanelTitle) + 2
+	clearStartX := panelStartX + 2 + prefixLen
+	clearEndX := clearStartX + 7
+
+	return msg.X >= clearStartX && msg.X < clearEndX
+}