@owdproject/cli 0.1.0 → 0.2.1

package/go/tui/tasks.go

@@ -0,0 +1,850 @@
+package tui
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
+
+	"owd-cli/bridge"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+// ─────────────────────────────────────────────
+// Background tasks
+// ─────────────────────────────────────────────
+
+type ProcessResult struct {
+	ExitCode int
+	Err      error
+}
+
+func (r *RuntimeState) runProcessStream(cwd, command string, args []string) ProcessResult {
+	cmdLine := command + " " + strings.Join(args, " ")
+	r.msgChan <- logLineMsg("ℹ " + cmdLine)
+
+	cmd := exec.Command(command, args...)
+	cmd.Dir = cwd
+
+	stdout, err := cmd.StdoutPipe()
+	if err != nil {
+		r.msgChan <- logLineMsg(fmt.Sprintf("✖ Failed to pipe stdout: %v", err))
+		return ProcessResult{ExitCode: 1, Err: err}
+	}
+	cmd.Stderr = cmd.Stdout
+
+	if err := cmd.Start(); err != nil {
+		r.msgChan <- logLineMsg(fmt.Sprintf("✖ Failed to start process: %v", err))
+		return ProcessResult{ExitCode: 1, Err: err}
+	}
+
+	reader := bufio.NewReader(stdout)
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			break
+		}
+		r.msgChan <- logLineMsg(strings.TrimRight(line, "\r\n"))
+	}
+
+	err = cmd.Wait()
+	exitCode := 0
+	if err != nil {
+		if exitErr, ok := err.(*exec.ExitError); ok {
+			exitCode = exitErr.ExitCode()
+		} else {
+			exitCode = 1
+		}
+		r.msgChan <- logLineMsg(fmt.Sprintf("✖ Command failed (exit %d): %v", exitCode, err))
+	} else {
+		r.msgChan <- logLineMsg(fmt.Sprintf("✔ Command completed (exit 0)"))
+	}
+	return ProcessResult{ExitCode: exitCode, Err: err}
+}
+
+func (r *RuntimeState) runProcessAndStreamLogs(root, command string, args []string) {
+	result := r.runProcessStream(root, command, args)
+	r.msgChan <- taskFinishedMsg{Success: result.Err == nil, Err: result.Err}
+}
+
+func (r *RuntimeState) runProcessAndStreamLogsSilent(root, command string, args []string) error {
+	result := r.runProcessStream(root, command, args)
+	return result.Err
+}
+
+func (m *TuiModel) RunSetupTask(adds map[string]string) {
+	workspaceRoot := m.workspaceRoot
+	msgChan := m.runtime.msgChan
+	runtime := m.runtime
+
+	var catalogEntries []bridge.CatalogEntry
+	if m.catalog != nil {
+		catalogEntries = make([]bridge.CatalogEntry, len(m.catalog.Entries))
+		copy(catalogEntries, m.catalog.Entries)
+	}
+
+	currentBatch := make(map[string]string)
+	for k, v := range adds {
+		currentBatch[k] = v
+	}
+
+	cloneCount := 0
+	for _, method := range adds {
+		if method == "git-https" || method == "git-ssh" {
+			cloneCount++
+		}
+	}
+	totalSteps := cloneCount + 2
+	step := 0
+
+	go func() {
+		msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Initializing…"}
+
+		// clonedDirs tracks successfully cloned target directories for dep scanning in this batch
+		type clonedInfo struct {
+			shortName string
+			targetDir string
+			pkgName   string
+		}
+		var clonedDirs []clonedInfo
+
+		// ── Phase 1: Clone each package in the current batch ──────────────────
+		for pkgName, method := range currentBatch {
+			shortName := pkgName
+			if idx := strings.LastIndex(pkgName, "/"); idx >= 0 {
+				shortName = pkgName[idx+1:]
+			}
+
+			if method == "npm" {
+				msgChan <- logLineMsg(fmt.Sprintf("ℹ %s will be installed via npm (pnpm install)", shortName))
+				continue
+			}
+			if method == "local" {
+				msgChan <- logLineMsg(fmt.Sprintf("ℹ %s already available as local workspace package", shortName))
+				continue
+			}
+
+			// Determine target directory
+			kindDir := kindDirForEntry(pkgName, shortName, catalogEntries)
+			targetDir := filepath.Join(workspaceRoot, kindDir, shortName)
+
+			// Skip if already cloned
+			if _, err := os.Stat(filepath.Join(targetDir, "package.json")); err == nil {
+				msgChan <- logLineMsg(fmt.Sprintf("ℹ %s already cloned — skipping", shortName))
+				clonedDirs = append(clonedDirs, clonedInfo{shortName, targetDir, pkgName})
+				continue
+			}
+
+			step++
+			msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: fmt.Sprintf("Cloning %s…", shortName)}
+
+			// Resolve git URL
+			owner := resolveOwner(pkgName, catalogEntries)
+			var gitURL string
+			if method == "git-ssh" {
+				gitURL = fmt.Sprintf("git@github.com:%s/%s.git", owner, shortName)
+			} else {
+				gitURL = fmt.Sprintf("https://github.com/%s/%s.git", owner, shortName)
+			}
+
+			msgChan <- logLineMsg(fmt.Sprintf("ℹ Cloning %s from %s", shortName, gitURL))
+			if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "git", []string{"clone", gitURL, targetDir}); err != nil {
+				msgChan <- logLineMsg(fmt.Sprintf("✗ Clone failed for %s: %v", shortName, err))
+				msgChan <- taskFinishedMsg{Success: false, Err: err}
+				return
+			}
+			msgChan <- logLineMsg(fmt.Sprintf("✓ %s cloned", shortName))
+			clonedDirs = append(clonedDirs, clonedInfo{shortName, targetDir, pkgName})
+		}
+
+		// ── Phase 1.5: Recursively scan and clone missing workspace dependencies ──
+		msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Scanning package dependencies…"}
+
+		logFunc := func(line string) { msgChan <- logLineMsg(line) }
+		if err := ResolveAndCloneMissingDependencies(workspaceRoot, catalogEntries, runtime, logFunc, msgChan, &step, &totalSteps); err != nil {
+			msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// ── Phase 2: pnpm install ─────────────────────────────────────────────
+		step++
+		msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Installing dependencies (pnpm install)…"}
+		msgChan <- logLineMsg("ℹ Running pnpm install (syncing workspace)…")
+		if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "pnpm", []string{"install"}); err != nil {
+			msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// ── Phase 3: Rebuild stubs ────────────────────────────────────────────
+		step++
+		msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Rebuilding stubs (prepare:modules)…"}
+		msgChan <- logLineMsg("ℹ Rebuilding stubs…")
+		if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "pnpm", []string{"run", "prepare:modules"}); err != nil {
+			msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		time.Sleep(500 * time.Millisecond)
+		msgChan <- taskFinishedMsg{Success: true}
+	}()
+}
+
+// kindDirForEntry resolves the workspace subdirectory for a package.
+// Uses catalog entries first, falls back to shortname prefix.
+func kindDirForEntry(pkgName, shortName string, entries []bridge.CatalogEntry) string {
+	for _, e := range entries {
+		if e.Name == pkgName {
+			switch e.Kind {
+			case "app":
+				return "apps"
+			case "module":
+				return "packages"
+			case "theme":
+				return "themes"
+			}
+		}
+	}
+	return kindDirForShortName(shortName)
+}
+
+// kindDirForShortName infers the workspace subdirectory from the package short name.
+func kindDirForShortName(shortName string) string {
+	switch {
+	case strings.HasPrefix(shortName, "app-"):
+		return "apps"
+	case strings.HasPrefix(shortName, "theme-"):
+		return "themes"
+	default:
+		return "packages" // module-*, kit-*, and anything else
+	}
+}
+
+// resolveOwner returns the GitHub owner to use for cloning.
+// Priority: fork owner (if fork is confirmed to exist) > catalog org > "owdproject".
+func resolveOwner(pkgName string, entries []bridge.CatalogEntry) string {
+	var entry *bridge.CatalogEntry
+	for i := range entries {
+		if entries[i].Name == pkgName {
+			entry = &entries[i]
+			break
+		}
+	}
+	if entry != nil && entry.SourcesMeta != nil && entry.SourcesMeta.Github.Fork != nil && entry.SourcesMeta.Github.Fork.Exists && entry.SourcesMeta.Github.Fork.IsFork {
+		return entry.SourcesMeta.Github.Fork.Owner
+	}
+	if entry != nil && entry.Org != "" && entry.Org != "workspace" {
+		return entry.Org
+	}
+	return "owdproject"
+}
+
+
+func (m *TuiModel) RunUpdatePackageTask(pkgName string, shortName string, kind string, isLocalSource bool) {
+	workspaceRoot := m.workspaceRoot
+	runtime := m.runtime
+
+	go func() {
+		runtime.msgChan <- clearLogsMsg{}
+		runtime.msgChan <- logLineMsg(fmt.Sprintf("ℹ Starting update for %s…", shortName))
+		runtime.msgChan <- setupProgressMsg{Step: 1, Total: 3, Label: fmt.Sprintf("Updating %s…", shortName)}
+
+		desktopJs := filepath.Join(workspaceRoot, "packages", "cli", "bin", "desktop.js")
+
+		if isLocalSource {
+			kindDir := ""
+			switch kind {
+			case "app":
+				kindDir = "apps"
+			case "module":
+				kindDir = "packages"
+			case "theme":
+				kindDir = "themes"
+			}
+
+			if kindDir != "" {
+				pkgPath := filepath.Join(workspaceRoot, kindDir, shortName)
+				runtime.msgChan <- logLineMsg(fmt.Sprintf("ℹ Running git pull in %s…", pkgPath))
+				if err := runtime.runProcessAndStreamLogsSilent(pkgPath, "git", []string{"pull"}); err != nil {
+					runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Git pull failed: %v", err))
+					runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+					return
+				}
+			}
+		} else {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("ℹ Re-installing %s from NPM to get latest version…", shortName))
+			args := []string{desktopJs, "add", shortName, "--npm"}
+			if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "node", args); err != nil {
+				runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ NPM update failed: %v", err))
+				runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+				return
+			}
+		}
+
+		// Run pnpm install
+		runtime.msgChan <- setupProgressMsg{Step: 2, Total: 3, Label: "Installing dependencies (pnpm install)…"}
+		runtime.msgChan <- logLineMsg("ℹ Running pnpm install (syncing workspace)…")
+		if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "pnpm", []string{"install"}); err != nil {
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// Rebuild stubs
+		runtime.msgChan <- setupProgressMsg{Step: 3, Total: 3, Label: "Rebuilding stubs (prepare:modules)…"}
+		runtime.msgChan <- logLineMsg("ℹ Rebuilding stubs…")
+		if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "pnpm", []string{"run", "prepare:modules"}); err != nil {
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		runtime.msgChan <- taskFinishedMsg{Success: true}
+	}()
+}
+
+func (m *TuiModel) RunServeTask() {
+	var metaDir string
+	var isPlayground bool
+	var packageDir string
+	var devPort int
+
+	if m.ctx != nil {
+		metaDir = m.ctx.Paths.MetaDir
+		isPlayground = m.ctx.Paths.IsPlayground
+		packageDir = m.ctx.Paths.PackageDir
+		devPort = m.ctx.Settings.DevPort
+	}
+	workspaceRoot := m.workspaceRoot
+	runtime := m.runtime
+
+	go func() {
+		if metaDir == "" {
+			runtime.msgChan <- serverStatusMsg{Running: false}
+			return
+		}
+
+		_ = os.MkdirAll(metaDir, 0755)
+
+		logPath := filepath.Join(metaDir, "dev.log")
+		logFile, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+		if err != nil {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Failed to open log file: %v", err))
+			runtime.msgChan <- serverStatusMsg{Running: false}
+			return
+		}
+		defer logFile.Close()
+
+		logFile.WriteString("ℹ Starting Nuxt dev server (pnpm run dev)…\n")
+
+		cmd := exec.Command("pnpm", "run", "dev")
+		if isPlayground {
+			cmd.Dir = packageDir
+		} else {
+			cmd.Dir = workspaceRoot
+		}
+
+		if devPort == 0 {
+			devPort = 3000
+		}
+		cmd.Env = append(os.Environ(), fmt.Sprintf("PORT=%d", devPort))
+		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+		cmd.Stdout = logFile
+		cmd.Stderr = logFile
+
+		runtime.serverMu.Lock()
+		runtime.serverCmd = cmd
+		runtime.serverMu.Unlock()
+
+		if err := cmd.Start(); err != nil {
+			logFile.WriteString(fmt.Sprintf("✗ Server failed to start: %v\n", err))
+			runtime.msgChan <- serverStatusMsg{Running: false}
+			return
+		}
+
+		// Write PID file
+		pidPath := filepath.Join(metaDir, "dev.pid")
+		_ = os.WriteFile(pidPath, []byte(fmt.Sprintf("%d", cmd.Process.Pid)), 0644)
+
+		runtime.msgChan <- serverStatusMsg{Running: true}
+
+		cmd.Wait()
+		logFile.WriteString("ℹ Dev server exited.\n")
+		runtime.msgChan <- serverStatusMsg{Running: false}
+
+		runtime.serverMu.Lock()
+		runtime.serverCmd = nil
+		runtime.serverMu.Unlock()
+	}()
+}
+
+func stopServeTaskSync(workspaceRoot, metaDir string, runtime *RuntimeState) {
+	if metaDir == "" {
+		runtime.msgChan <- serverStatusMsg{Running: false}
+		return
+	}
+
+	runtime.serverMu.Lock()
+	cmd := runtime.serverCmd
+	runtime.serverCmd = nil
+	runtime.serverMu.Unlock()
+
+	if cmd != nil && cmd.Process != nil {
+		_ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL)
+	}
+
+	pidPath := filepath.Join(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 && pid > 0 {
+			_ = syscall.Kill(-pid, syscall.SIGKILL)
+			_ = syscall.Kill(pid, syscall.SIGKILL)
+		}
+		_ = os.Remove(pidPath)
+	}
+
+	// Safe, scoped process cleanup targeting processes for this workspace
+	killWorkspaceProcesses(workspaceRoot)
+
+	runtime.msgChan <- serverStatusMsg{Running: false}
+}
+
+func (m *TuiModel) StopServeTask() {
+	var metaDir string
+	if m.ctx != nil {
+		metaDir = m.ctx.Paths.MetaDir
+	}
+	workspaceRoot := m.workspaceRoot
+	runtime := m.runtime
+
+	go func() {
+		stopServeTaskSync(workspaceRoot, metaDir, runtime)
+	}()
+}
+
+func (m *TuiModel) StopLogTailer() {
+	m.runtime.serverMu.Lock()
+	defer m.runtime.serverMu.Unlock()
+	if m.runtime.logCancel != nil {
+		m.runtime.logCancel()
+		m.runtime.logCancel = nil
+	}
+}
+
+func (m *TuiModel) StartLogTailer(logPath string) {
+	m.StopLogTailer()
+
+	m.runtime.serverMu.Lock()
+	ctx, cancel := context.WithCancel(context.Background())
+	m.runtime.logCancel = cancel
+	m.runtime.serverMu.Unlock()
+
+	runtime := m.runtime
+
+	go func() {
+		var lastSize int64 = 0
+
+		// Check if file exists and get its initial size
+		if info, err := os.Stat(logPath); err == nil {
+			lastSize = info.Size()
+			// Seek back up to 10000 bytes (~100 lines) to show initial history
+			offset := lastSize - 10000
+			if offset < 0 {
+				offset = 0
+			}
+
+			file, err := os.Open(logPath)
+			if err == nil {
+				_, _ = file.Seek(offset, 0)
+				reader := bufio.NewReader(file)
+				if offset > 0 {
+					_, _ = reader.ReadString('\n') // discard first potentially cut line
+				}
+				for {
+					select {
+					case <-ctx.Done():
+						file.Close()
+						return
+					default:
+					}
+					line, err := reader.ReadString('\n')
+					if err != nil {
+						break
+					}
+					runtime.msgChan <- logLineMsg(strings.TrimRight(line, "\r\n"))
+				}
+				file.Close()
+			}
+		}
+
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+			}
+
+			time.Sleep(250 * time.Millisecond)
+
+			info, err := os.Stat(logPath)
+			if err != nil {
+				continue
+			}
+
+			if info.Size() < lastSize {
+				// File was truncated/cleared
+				lastSize = info.Size()
+				runtime.msgChan <- clearLogsMsg{}
+				continue
+			}
+
+			if info.Size() > lastSize {
+				file, err := os.Open(logPath)
+				if err != nil {
+					continue
+				}
+				_, err = file.Seek(lastSize, 0)
+				if err != nil {
+					file.Close()
+					continue
+				}
+
+				reader := bufio.NewReader(file)
+				for {
+					select {
+					case <-ctx.Done():
+						file.Close()
+						return
+					default:
+					}
+					line, err := reader.ReadString('\n')
+					if err != nil {
+						break
+					}
+					runtime.msgChan <- logLineMsg(strings.TrimRight(line, "\r\n"))
+				}
+				lastSize = info.Size()
+				file.Close()
+			}
+		}
+	}()
+}
+
+func (m *TuiModel) RunWipeWorkspaceTask() {
+	workspaceRoot := m.workspaceRoot
+	runtime := m.runtime
+
+	go func() {
+		runtime.msgChan <- clearLogsMsg{}
+		runtime.msgChan <- logLineMsg("ℹ Starting workspace reset task…")
+
+		totalSteps := 7
+		step := 0
+
+		// Step 1: Clean apps/
+		step++
+		runtime.msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Cleaning apps directory…"}
+		runtime.msgChan <- logLineMsg("ℹ Cleaning apps/ directory…")
+		if err := wipeDirectory(filepath.Join(workspaceRoot, "apps"), nil); err != nil {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Error cleaning apps: %v", err))
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// Step 2: Clean themes/
+		step++
+		runtime.msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Cleaning themes directory…"}
+		runtime.msgChan <- logLineMsg("ℹ Cleaning themes/ directory…")
+		if err := wipeDirectory(filepath.Join(workspaceRoot, "themes"), nil); err != nil {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Error cleaning themes: %v", err))
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// Step 3: Clean packages/ (preserving core, cli, nx)
+		step++
+		runtime.msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Cleaning packages directory…"}
+		runtime.msgChan <- logLineMsg("ℹ Cleaning packages/ directory (preserving core, cli, nx)…")
+		preservePkgs := map[string]bool{"core": true, "cli": true, "nx": true}
+		if err := wipeDirectory(filepath.Join(workspaceRoot, "packages"), preservePkgs); err != nil {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Error cleaning packages: %v", err))
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// Step 4: Reset desktop.config.ts
+		step++
+		runtime.msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Resetting desktop config…"}
+		runtime.msgChan <- logLineMsg("ℹ Resetting desktop/desktop.config.ts to default…")
+		defaultConfig := `import { defineDesktopConfig } from '@owdproject/core'
+
+export default defineDesktopConfig({
+  theme: '',
+  apps: [],
+  modules: [],
+})
+`
+		configPath := filepath.Join(workspaceRoot, "desktop", "desktop.config.ts")
+		if err := os.WriteFile(configPath, []byte(defaultConfig), 0644); err != nil {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Error resetting desktop config: %v", err))
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// Step 5: Reset package.json
+		step++
+		runtime.msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Resetting package dependencies…"}
+		runtime.msgChan <- logLineMsg("ℹ Resetting desktop/package.json dependencies to core only…")
+		defaultPackageJson := `{
+  "name": "@owdproject/client",
+  "private": true,
+  "nx": {
+    "name": "desktop"
+  },
+  "scripts": {
+    "build": "nuxt generate",
+    "dev": "nuxt dev --host",
+    "generate": "nuxt generate --dev",
+    "postinstall": "nuxt prepare",
+    "preview": "nuxt preview",
+    "desktop": "desktop"
+  },
+  "dependencies": {
+    "@owdproject/core": "workspace:*"
+  }
+}
+`
+		pkgJsonPath := filepath.Join(workspaceRoot, "desktop", "package.json")
+		if err := os.WriteFile(pkgJsonPath, []byte(defaultPackageJson), 0644); err != nil {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Error resetting package.json: %v", err))
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// Step 6: Run pnpm install
+		step++
+		runtime.msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Installing dependencies (pnpm install)…"}
+		runtime.msgChan <- logLineMsg("ℹ Running pnpm install (syncing workspace)…")
+		if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "pnpm", []string{"install"}); err != nil {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Error running pnpm install: %v", err))
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		// Step 7: Run prepare:modules
+		step++
+		runtime.msgChan <- setupProgressMsg{Step: step, Total: totalSteps, Label: "Rebuilding stubs (prepare:modules)…"}
+		runtime.msgChan <- logLineMsg("ℹ Rebuilding stubs…")
+		if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "pnpm", []string{"run", "prepare:modules"}); err != nil {
+			runtime.msgChan <- logLineMsg(fmt.Sprintf("✗ Error running prepare:modules: %v", err))
+			runtime.msgChan <- taskFinishedMsg{Success: false, Err: err}
+			return
+		}
+
+		runtime.msgChan <- taskFinishedMsg{Success: true}
+	}()
+}
+
+// killWorkspaceProcesses kills any target processes (node, nuxt, etc.) that are associated with the workspaceRoot
+func killWorkspaceProcesses(workspaceRoot string) {
+	entries, err := os.ReadDir("/proc")
+	if err != nil {
+		return
+	}
+	myPid := os.Getpid()
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		name := entry.Name()
+		var pid int
+		if _, err := fmt.Sscanf(name, "%d", &pid); err != nil || pid <= 0 {
+			continue
+		}
+		if pid == myPid {
+			continue
+		}
+
+		cmdlinePath := fmt.Sprintf("/proc/%d/cmdline", pid)
+		data, err := os.ReadFile(cmdlinePath)
+		if err != nil {
+			continue
+		}
+
+		args := strings.Split(string(data), "\x00")
+		if len(args) == 0 || args[0] == "" {
+			continue
+		}
+
+		hasWorkspace := false
+		for _, arg := range args {
+			if strings.Contains(arg, workspaceRoot) {
+				hasWorkspace = true
+				break
+			}
+		}
+
+		if !hasWorkspace {
+			continue
+		}
+
+		exe := args[0]
+		isTarget := false
+		targets := []string{"node", "nuxt", "nuxi", "pnpm", "vite", "nitro", "next"}
+		for _, t := range targets {
+			if strings.Contains(strings.ToLower(exe), t) {
+				isTarget = true
+				break
+			}
+		}
+
+		if !isTarget {
+			for _, arg := range args {
+				for _, t := range targets {
+					if strings.Contains(strings.ToLower(arg), t) {
+						isTarget = true
+						break
+					}
+				}
+				if isTarget {
+					break
+				}
+			}
+		}
+
+		if isTarget {
+			// Kill process group, then the process itself
+			_ = syscall.Kill(-pid, syscall.SIGKILL)
+			_ = syscall.Kill(pid, syscall.SIGKILL)
+		}
+	}
+}
+
+// ResolveAndCloneMissingDependencies recursively scans the workspace for any missing workspace:* dependencies and clones them.
+func ResolveAndCloneMissingDependencies(
+	workspaceRoot string,
+	catalogEntries []bridge.CatalogEntry,
+	runtime *RuntimeState,
+	log func(string),
+	msgChan chan<- tea.Msg,
+	step *int,
+	totalSteps *int,
+) error {
+	inWorkspace := map[string]bool{}
+
+	scanWorkspace := func() ([]string, error) {
+		localFolders := []string{filepath.Join(workspaceRoot, "desktop")}
+		dirs := []string{"apps", "packages", "themes"}
+		for _, d := range dirs {
+			p := filepath.Join(workspaceRoot, d)
+			entries, err := os.ReadDir(p)
+			if err != nil {
+				continue
+			}
+			for _, entry := range entries {
+				if entry.IsDir() {
+					localFolders = append(localFolders, filepath.Join(p, entry.Name()))
+				}
+			}
+		}
+
+		// Clean/reset inWorkspace map
+		for k := range inWorkspace {
+			delete(inWorkspace, k)
+		}
+
+		for _, folder := range localFolders {
+			data, err := os.ReadFile(filepath.Join(folder, "package.json"))
+			if err != nil {
+				continue
+			}
+			var pkg struct {
+				Name string `json:"name"`
+			}
+			if json.Unmarshal(data, &pkg) == nil && pkg.Name != "" {
+				inWorkspace[pkg.Name] = true
+			}
+		}
+
+		var missing []string
+		for _, folder := range localFolders {
+			data, err := os.ReadFile(filepath.Join(folder, "package.json"))
+			if err != nil {
+				continue
+			}
+			var pkg struct {
+				Dependencies    map[string]string `json:"dependencies"`
+				DevDependencies map[string]string `json:"devDependencies"`
+			}
+			if json.Unmarshal(data, &pkg) != nil {
+				continue
+			}
+
+			allDeps := make(map[string]string)
+			for k, v := range pkg.Dependencies {
+				allDeps[k] = v
+			}
+			for k, v := range pkg.DevDependencies {
+				allDeps[k] = v
+			}
+
+			for depName, depVer := range allDeps {
+				if !strings.HasPrefix(depName, "@owdproject/") {
+					continue
+				}
+				if !strings.HasPrefix(depVer, "workspace:") {
+					continue
+				}
+				if !inWorkspace[depName] {
+					alreadyAdded := false
+					for _, m := range missing {
+						if m == depName {
+							alreadyAdded = true
+							break
+						}
+					}
+					if !alreadyAdded {
+						missing = append(missing, depName)
+					}
+				}
+			}
+		}
+		return missing, nil
+	}
+
+	for {
+		missing, err := scanWorkspace()
+		if err != nil || len(missing) == 0 {
+			break
+		}
+
+		depName := missing[0]
+		depShort := depName[strings.LastIndex(depName, "/")+1:]
+		depKindDir := kindDirForShortName(depShort)
+		depTarget := filepath.Join(workspaceRoot, depKindDir, depShort)
+
+		owner := resolveOwner(depName, catalogEntries)
+		gitURL := fmt.Sprintf("https://github.com/%s/%s.git", owner, depShort)
+
+		if step != nil && totalSteps != nil && msgChan != nil {
+			*totalSteps++
+			*step++
+			msgChan <- setupProgressMsg{Step: *step, Total: *totalSteps, Label: fmt.Sprintf("Cloning dep %s…", depShort)}
+		}
+		log(fmt.Sprintf("ℹ Auto-cloning missing workspace dependency %s from %s", depShort, gitURL))
+
+		if err := runtime.runProcessAndStreamLogsSilent(workspaceRoot, "git", []string{"clone", gitURL, depTarget}); err != nil {
+			log(fmt.Sprintf("✗ Auto-clone failed for %s: %v", depShort, err))
+			return err
+		}
+		log(fmt.Sprintf("✓ %s auto-cloned", depShort))
+		inWorkspace[depName] = true
+	}
+
+	return nil
+}
+