app.go

package main

import (
	"bufio"
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"net"
	"net/http"
	"os"
	"path"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/pkg/sftp"
	"github.com/rymdport/portal/filechooser"
	"github.com/rymdport/portal/openuri"
	"github.com/rymdport/portal/settings"
	"github.com/rymdport/portal/settings/appearance"
	"github.com/skratchdot/open-golang/open"
	"github.com/wailsapp/wails/v2/pkg/runtime"
	"golang.org/x/crypto/ssh"
	"gopkg.in/ini.v1"

	"reManager/internal/backup"
	"reManager/internal/commands"
	"reManager/internal/component"
	"reManager/internal/debug"
	"reManager/internal/device"
	apperrors "reManager/internal/errors"
	"reManager/internal/executor"
	"reManager/internal/httputil"
	"reManager/internal/installer"
	"reManager/internal/logger"
	"reManager/internal/epubimport"
	"reManager/internal/pdfimport"
	"reManager/internal/rmdocimport"
	"reManager/internal/platform"
	"reManager/internal/sshagent"
	"reManager/internal/storage"
	"reManager/internal/support"
	"reManager/internal/swupdate"
	"reManager/internal/vellum"

	rmdevice "github.com/rmitchellscott/remarkable-go/device"
	rmexecutor "github.com/rmitchellscott/remarkable-go/executor"
	rmfilesystem "github.com/rmitchellscott/remarkable-go/filesystem"
	"github.com/rmitchellscott/remarkable-go/partition"
	rmupdate "github.com/rmitchellscott/remarkable-go/update"
)

func resolveDialogDir(defaultDir string) string {
	if defaultDir != "" {
		if info, err := os.Stat(defaultDir); err == nil && info.IsDir() {
			return defaultDir
		}
	}
	home, _ := os.UserHomeDir()
	return home
}

func openFileDialog(ctx context.Context, title, defaultDir string) (string, error) {
	dir := resolveDialogDir(defaultDir)
	if platform.IsRunningInFlatpak() {
		files, err := filechooser.OpenFile("", title, &filechooser.OpenFileOptions{
			CurrentFolder: dir,
		})
		fmt.Println("[DEBUG] openFileDialog: files:", files, "err:", err)
		if err != nil {
			return "", err
		}
		if len(files) == 0 {
			return "", nil
		}
		return strings.TrimPrefix(files[0], "file://"), nil
	}
	return runtime.OpenFileDialog(ctx, runtime.OpenDialogOptions{
		Title:            title,
		DefaultDirectory: dir,
	})
}

func openMultipleFilesDialog(ctx context.Context, title, defaultDir string) ([]string, error) {
	dir := resolveDialogDir(defaultDir)
	if platform.IsRunningInFlatpak() {
		files, err := filechooser.OpenFile("", title, &filechooser.OpenFileOptions{
			CurrentFolder: dir,
			Multiple:      true,
		})
		fmt.Println("[DEBUG] openMultipleFilesDialog: files:", files, "err:", err)
		if err != nil {
			return nil, err
		}
		for i, f := range files {
			files[i] = strings.TrimPrefix(f, "file://")
		}
		return files, nil
	}
	return runtime.OpenMultipleFilesDialog(ctx, runtime.OpenDialogOptions{
		Title:            title,
		DefaultDirectory: dir,
	})
}

func saveFileDialog(ctx context.Context, title, defaultFilename, defaultDir string) (string, error) {
	dir := resolveDialogDir(defaultDir)
	if platform.IsRunningInFlatpak() {
		files, err := filechooser.SaveFile("", title, &filechooser.SaveFileOptions{
			CurrentFolder: dir,
			CurrentName:   defaultFilename,
		})
		fmt.Println("[DEBUG] saveFileDialog: files:", files, "err:", err)
		if err != nil {
			return "", err
		}
		if len(files) == 0 {
			return "", nil
		}
		return strings.TrimPrefix(files[0], "file://"), nil
	}
	return runtime.SaveFileDialog(ctx, runtime.SaveDialogOptions{
		Title:            title,
		DefaultFilename:  defaultFilename,
		DefaultDirectory: dir,
	})
}

func openDirectoryDialog(ctx context.Context, title, defaultDir string) (string, error) {
	dir := resolveDialogDir(defaultDir)
	if platform.IsRunningInFlatpak() {
		files, err := filechooser.OpenFile("", title, &filechooser.OpenFileOptions{
			CurrentFolder: dir,
			Directory:     true,
		})
		fmt.Println("[DEBUG] openDirectoryDialog: files:", files, "err:", err)
		if err != nil {
			return "", err
		}
		if len(files) == 0 {
			return "", nil
		}
		return strings.TrimPrefix(files[0], "file://"), nil
	}
	return runtime.OpenDirectoryDialog(ctx, runtime.OpenDialogOptions{
		Title:            title,
		DefaultDirectory: dir,
	})
}

func sanitizeFilename(name string) string {
	replacer := strings.NewReplacer("/", "_", "\\", "_", ":", "_", " ", "-", "<", "_", ">", "_", "\"", "_", "|", "_", "?", "_", "*", "_")
	return replacer.Replace(name)
}

type App struct {
	ctx            context.Context
	client         *ssh.Client
	session        *ssh.Session
	mu             sync.Mutex
	connectCancel  context.CancelFunc
	commandCancel  context.CancelFunc
	commandSession *ssh.Session
	commandStdin   io.WriteCloser
	dialogResponse chan string
	deviceStore    *storage.DeviceStore
	settingsStore  *storage.SettingsStore
	bundleStore      *storage.BundleStore
	deviceInfoCache  *storage.DeviceInfoCacheStore
	vellumClient   *vellum.Client
	metadata       *vellum.MetadataStore

	logger          *logger.Logger
	operationLog    *logger.CommandLog
	supportBundleID string

	keepaliveStop          chan struct{}
	connectedDeviceID      string
	connectedDeviceType    string
	writeableRootBusy      bool
	reconnecting           bool
	reconnectMu            sync.Mutex
	fastDialMode           bool
	installCancelCh        chan struct{}
	osInstallCancelCh      chan struct{}
	backupCancelCh         chan struct{}
	backupMu               sync.Mutex
	folderTransferCancelCh chan struct{}
	folderTransferMu       sync.Mutex

	agentConn net.Conn

	shellSession *ssh.Session
	shellStdin   io.WriteCloser
	shellMu      sync.Mutex
	shellActive  bool

	preventSleepStop chan struct{}
	penInputDevice   string
}

func NewApp() *App {
	return &App{}
}

func (a *App) startup(ctx context.Context) {
	a.ctx = ctx

	configDir, err := storage.GetConfigDir()
	if err == nil {
		l, lerr := logger.New(configDir)
		if lerr == nil {
			a.logger = l
			debug.SetFileLogger(l)
			a.logger.LogEvent("APP", "reManager starting, version="+version)
			go a.logger.CleanupOldCommandLogs(30 * 24 * time.Hour)
		}
	}

	store, err := storage.NewDeviceStore()
	if err != nil {
		fmt.Printf("Warning: could not initialize device store: %v\n", err)
	}
	a.deviceStore = store

	settingsStore, err := storage.NewSettingsStore()
	if err != nil {
		fmt.Printf("Warning: could not initialize settings store: %v\n", err)
	}
	a.settingsStore = settingsStore

	bundleStore, err := storage.NewBundleStore()
	if err != nil {
		fmt.Printf("Warning: could not initialize bundle store: %v\n", err)
	}
	a.bundleStore = bundleStore

	deviceInfoCache, err := storage.NewDeviceInfoCacheStore()
	if err != nil {
		fmt.Printf("Warning: could not initialize device info cache: %v\n", err)
	}
	a.deviceInfoCache = deviceInfoCache

	a.metadata = vellum.NewMetadataStore()
	if err := a.metadata.Load(); err != nil {
		fmt.Printf("Warning: could not load metadata: %v\n", err)
	}

	go func() {
		settings.OnSignalSettingChanged(func(changed settings.Changed) {
			if changed.Namespace == appearance.Namespace && changed.Key == "color-scheme" {
				scheme, err := appearance.ValueToColorScheme(changed.Value)
				if err == nil {
					var themeName string
					switch scheme {
					case appearance.Dark:
						themeName = "dark"
					case appearance.Light:
						themeName = "light"
					default:
						themeName = "unknown"
					}
					runtime.EventsEmit(a.ctx, "system-theme-changed", themeName)
				}
			}
		})
	}()
}

func (a *App) shutdown(ctx context.Context) {
	if a.logger != nil {
		a.logger.LogEvent("APP", "reManager shutting down")
	}
	a.Disconnect()
	if a.logger != nil {
		a.logger.Close()
	}
}

type ConnectionResult struct {
	Success   bool   `json:"success"`
	Message   string `json:"message"`
	Code      string `json:"code,omitempty"`
	Retryable bool   `json:"retryable,omitempty"`
	Device    string `json:"device,omitempty"`
}

type SSHKey struct {
	Path string `json:"path"`
	Name string `json:"name"`
}

func (a *App) GetDefaultSSHKeys() []SSHKey {
	home, err := os.UserHomeDir()
	if err != nil {
		return nil
	}

	sshDir := filepath.Join(home, ".ssh")
	entries, err := os.ReadDir(sshDir)
	if err != nil {
		return nil
	}

	var keys []SSHKey
	for _, e := range entries {
		if e.IsDir() {
			continue
		}
		name := e.Name()
		if strings.HasPrefix(name, "id_") && !strings.HasSuffix(name, ".pub") {
			keyPath := filepath.Join(sshDir, name)
			if info, err := os.Stat(keyPath); err == nil && info.Mode().IsRegular() {
				keys = append(keys, SSHKey{
					Path: keyPath,
					Name: name,
				})
			}
		}
	}

	return keys
}

func (a *App) SelectKeyFile() string {
	path, err := openFileDialog(a.ctx, "Select SSH Private Key", "")
	if err != nil {
		return ""
	}
	return path
}

type SavedDeviceInfo struct {
	ID            string `json:"id"`
	Name          string `json:"name"`
	Host          string `json:"host"`
	AuthType      string `json:"authType"`
	KeyPath       string `json:"keyPath,omitempty"`
	LastConnected int64  `json:"lastConnected,omitempty"`
	Timezone      string `json:"timezone,omitempty"`
}

func (a *App) GetSavedDevices() []SavedDeviceInfo {
	if a.deviceStore == nil {
		return []SavedDeviceInfo{}
	}

	devices, err := a.deviceStore.GetAll()
	if err != nil {
		fmt.Printf("Error getting saved devices: %v\n", err)
		return []SavedDeviceInfo{}
	}

	result := make([]SavedDeviceInfo, len(devices))
	for i, d := range devices {
		result[i] = SavedDeviceInfo{
			ID:            d.ID,
			Name:          d.Name,
			Host:          d.Host,
			AuthType:      d.AuthType,
			KeyPath:       d.KeyPath,
			LastConnected: d.LastConnected,
			Timezone:      d.Timezone,
		}
	}
	return result
}

func (a *App) SaveDevice(id, name, host, authType, password, keyPath, keyPassphrase string) (string, error) {
	if a.deviceStore == nil {
		return "", fmt.Errorf("device store not initialized")
	}

	device := storage.SavedDevice{
		ID:            id,
		Name:          name,
		Host:          host,
		AuthType:      authType,
		KeyPath:       keyPath,
		LastConnected: time.Now().Unix(),
	}

	return a.deviceStore.Save(device, password, keyPassphrase)
}

func (a *App) DeleteSavedDevice(id string) error {
	if a.deviceStore == nil {
		return fmt.Errorf("device store not initialized")
	}
	if err := a.deviceStore.Delete(id); err != nil {
		return err
	}
	if a.deviceInfoCache != nil {
		_ = a.deviceInfoCache.Delete(id)
	}
	return nil
}

func (a *App) UpdateDeviceName(id string, name string) error {
	if a.deviceStore == nil {
		return fmt.Errorf("device store not initialized")
	}
	return a.deviceStore.UpdateName(id, name)
}

func (a *App) ConnectToSavedDevice(id string) ConnectionResult {
	if a.deviceStore == nil {
		return ConnectionResult{
			Success:   false,
			Message:   "Device store not initialized.",
			Code:      apperrors.ErrStorageFailed,
			Retryable: false,
		}
	}

	device, err := a.deviceStore.Get(id)
	if err != nil {
		return ConnectionResult{
			Success:   false,
			Message:   "Saved device not found. It may have been deleted.",
			Code:      apperrors.ErrDeviceNotFound,
			Retryable: false,
		}
	}

	var result ConnectionResult
	if device.AuthType == "agent" {
		result = a.ConnectWithAuth(device.Host, "agent", "", "")
	} else if device.AuthType == "key" {
		passphrase, _ := a.deviceStore.GetKeyPassphrase(id)
		result = a.ConnectWithAuth(device.Host, "key", passphrase, device.KeyPath)
	} else {
		password, err := a.deviceStore.GetPassword(id)
		if err != nil {
			return ConnectionResult{
				Success:   false,
				Message:   "Could not retrieve password. Please reconnect and save the device again.",
				Code:      apperrors.ErrKeyringFailed,
				Retryable: false,
			}
		}
		result = a.ConnectWithAuth(device.Host, "password", password, "")
	}

	if result.Success {
		a.deviceStore.UpdateLastConnected(id, time.Now().Unix())

		a.mu.Lock()
		a.connectedDeviceID = id
		a.mu.Unlock()

		a.startConnectionMonitor()

		if settings, err := a.settingsStore.Load(); err == nil && settings.PreventSleep {
			debug.Println("[DEBUG] ConnectToSavedDevice: auto-starting prevent sleep")
			if err := a.StartPreventSleep(); err != nil {
				debug.Printf("[DEBUG] ConnectToSavedDevice: StartPreventSleep failed: %v\n", err)
			}
		}
	}

	return result
}

func (a *App) CheckVellumInstalled() bool {
	if a.vellumClient == nil {
		return false
	}
	installed, err := a.vellumClient.IsInstalled()
	if err != nil {
		return false
	}
	return installed
}

func (a *App) BootstrapVellum() {
	go func() {
		a.mu.Lock()
		sshClient := a.client
		a.mu.Unlock()

		if sshClient == nil {
			runtime.EventsEmit(a.ctx, "vellum:bootstrap-error", "Not connected")
			return
		}

		if a.vellumClient == nil {
			a.vellumClient = vellum.NewClient(&wailsExecutor{app: a})
		}

		deviceType, err := a.detectDevice()
		if err != nil {
			runtime.EventsEmit(a.ctx, "vellum:bootstrap-error", fmt.Sprintf("Failed to detect device: %v", err))
			return
		}

		arch := device.GetArchitecture(component.DeviceType(deviceType))

		runtime.EventsEmit(a.ctx, "vellum:bootstrap-start", nil)

		err = a.vellumClient.BootstrapOfflineWithPackages(sshClient, arch, func(line string) {
			runtime.EventsEmit(a.ctx, "vellum:bootstrap-output", line)
		})

		if err != nil {
			runtime.EventsEmit(a.ctx, "vellum:bootstrap-error", err.Error())
			return
		}

		runtime.EventsEmit(a.ctx, "vellum:bootstrap-complete", nil)
	}()
}

func (a *App) CheckPackageInstalled(pkgName string) bool {
	if a.vellumClient == nil {
		return false
	}
	installed, err := a.vellumClient.IsPackageInstalled(pkgName)
	if err != nil {
		return false
	}
	return installed
}

func (a *App) Connect(host, password string) ConnectionResult {
	return a.ConnectWithAuth(host, "password", password, "")
}

func (a *App) ConnectWithKey(host, keyPath, passphrase string) ConnectionResult {
	return a.ConnectWithAuth(host, "key", passphrase, keyPath)
}

func (a *App) ConnectWithAgent(host string) ConnectionResult {
	return a.ConnectWithAuth(host, "agent", "", "")
}

func (a *App) IsSSHAgentAvailable() bool {
	return sshagent.IsAvailable(a.sshAgentSocketPath())
}

func (a *App) sshAgentSocketPath() string {
	if a.settingsStore == nil {
		return ""
	}
	settings, err := a.settingsStore.Load()
	if err != nil {
		return ""
	}
	return settings.SSHAgentSocketPath
}

func (a *App) CancelConnect() {
	a.mu.Lock()
	defer a.mu.Unlock()
	if a.connectCancel != nil {
		a.connectCancel()
		a.connectCancel = nil
	}
}

func (a *App) dialWithContext(ctx context.Context, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
	timeout := 10 * time.Second
	if a.fastDialMode {
		timeout = 5 * time.Second
	}
	d := net.Dialer{Timeout: timeout}
	conn, err := d.DialContext(ctx, "tcp", addr)
	if err != nil {
		return nil, err
	}
	c, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
	if err != nil {
		conn.Close()
		return nil, err
	}
	return ssh.NewClient(c, chans, reqs), nil
}

func isRetryableError(err error) bool {
	if err == nil {
		return false
	}

	errStr := strings.ToLower(err.Error())

	nonRetryableKeywords := []string{
		"passphrase",
		"permission denied",
		"unable to authenticate",
		"ssh: handshake failed",
		"no auth",
		"authentication failed",
	}

	for _, keyword := range nonRetryableKeywords {
		if strings.Contains(errStr, keyword) {
			return false
		}
	}

	retryableKeywords := []string{
		"no route to host",
		"connection refused",
		"i/o timeout",
		"connection reset by peer",
		"network is unreachable",
		"host is down",
		"connection timed out",
		"broken pipe",
	}

	for _, keyword := range retryableKeywords {
		if strings.Contains(errStr, keyword) {
			return true
		}
	}

	var netErr net.Error
	if errors.As(err, &netErr) {
		if netErr.Timeout() || netErr.Temporary() {
			return true
		}
	}

	return false
}

func (a *App) dialWithContextWithRetry(ctx context.Context, addr string, config *ssh.ClientConfig) (*ssh.Client, error) {
	var maxRetries int
	var backoffDurations []time.Duration

	if a.fastDialMode {
		maxRetries = 0
		backoffDurations = []time.Duration{}
	} else {
		maxRetries = 3
		backoffDurations = []time.Duration{
			2 * time.Second,
			4 * time.Second,
			8 * time.Second,
		}
	}

	var lastErr error

	for attempt := 0; attempt <= maxRetries; attempt++ {
		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		default:
		}

		debug.Printf("[%s] dialWithContextWithRetry attempt %d/%d to %s\n", time.Now().Format("15:04:05.000"), attempt+1, maxRetries+1, addr)
		client, err := a.dialWithContext(ctx, addr, config)
		if err == nil {
			debug.Printf("[%s] dialWithContextWithRetry attempt %d/%d succeeded\n", time.Now().Format("15:04:05.000"), attempt+1, maxRetries+1)
			return client, nil
		}

		debug.Printf("[%s] dialWithContextWithRetry attempt %d/%d failed: %v\n", time.Now().Format("15:04:05.000"), attempt+1, maxRetries+1, err)
		lastErr = err

		if ctx.Err() == context.Canceled {
			return nil, context.Canceled
		}

		if !isRetryableError(err) {
			debug.Printf("[%s] Error not retryable, giving up\n", time.Now().Format("15:04:05.000"))
			return nil, err
		}

		if attempt == maxRetries {
			break
		}

		backoffDuration := backoffDurations[attempt]
		debug.Printf("[%s] dialWithContextWithRetry waiting %v before retry\n", time.Now().Format("15:04:05.000"), backoffDuration)

		select {
		case <-time.After(backoffDuration):
			continue
		case <-ctx.Done():
			return nil, context.Canceled
		}
	}

	return nil, lastErr
}

func (a *App) ConnectWithAuth(host, authType, secret, keyPath string) ConnectionResult {
	a.stopConnectionMonitor()

	a.mu.Lock()

	a.connectedDeviceID = ""

	if a.connectCancel != nil {
		a.connectCancel()
	}

	if a.client != nil {
		a.client.Close()
		a.client = nil
	}
	if a.agentConn != nil {
		a.agentConn.Close()
		a.agentConn = nil
	}

	ctx, cancel := context.WithCancel(context.Background())
	a.connectCancel = cancel

	a.mu.Unlock()

	var authMethods []ssh.AuthMethod

	if authType == "agent" {
		conn, authMethod, err := sshagent.Connect(a.sshAgentSocketPath())
		if err != nil {
			return ConnectionResult{
				Success:   false,
				Message:   err.Error(),
				Code:      apperrors.ErrAuthFailed,
				Retryable: false,
			}
		}
		a.mu.Lock()
		a.agentConn = conn
		a.mu.Unlock()
		authMethods = append(authMethods, authMethod)
	} else if authType == "key" {
		keyData, err := os.ReadFile(keyPath)
		if err != nil {
			ue := apperrors.Classify(err)
			return ConnectionResult{
				Success:   false,
				Message:   ue.Message,
				Code:      ue.Code,
				Retryable: ue.Retryable,
			}
		}

		var signer ssh.Signer
		if secret != "" {
			signer, err = ssh.ParsePrivateKeyWithPassphrase(keyData, []byte(secret))
		} else {
			signer, err = ssh.ParsePrivateKey(keyData)
		}
		if err != nil {
			ue := apperrors.Classify(err)
			return ConnectionResult{
				Success:   false,
				Message:   ue.Message,
				Code:      ue.Code,
				Retryable: ue.Retryable,
			}
		}
		authMethods = append(authMethods, ssh.PublicKeys(signer))
	} else {
		authMethods = append(authMethods, ssh.Password(secret))
	}

	config := &ssh.ClientConfig{
		User:            "root",
		Auth:            authMethods,
		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
		Config: ssh.Config{
			KeyExchanges: []string{
				"curve25519-sha256",
				"curve25519-sha256@libssh.org",
				"ecdh-sha2-nistp256",
				"ecdh-sha2-nistp384",
				"ecdh-sha2-nistp521",
				"diffie-hellman-group14-sha256",
				"diffie-hellman-group14-sha1",
				"diffie-hellman-group1-sha1",
			},
			Ciphers: []string{
				"chacha20-poly1305@openssh.com",
				"aes256-ctr",
				"aes128-ctr",
				"aes256-cbc",
				"aes128-cbc",
				"3des-cbc",
			},
			MACs: []string{
				"hmac-sha2-256",
				"hmac-sha1",
			},
		},
		// Explicit host key algorithms required for Dropbear 2022.83 compatibility
		HostKeyAlgorithms: []string{
			ssh.KeyAlgoED25519,
			ssh.KeyAlgoRSASHA256,
			ssh.KeyAlgoRSA,
		},
	}

	addr := host
	if !strings.Contains(host, ":") {
		addr = host + ":22"
	}

	client, err := a.dialWithContextWithRetry(ctx, addr, config)
	if err != nil {
		if ctx.Err() == context.Canceled {
			return ConnectionResult{
				Success:   false,
				Message:   "Connection cancelled.",
				Code:      apperrors.ErrOperationCancelled,
				Retryable: false,
			}
		}
		ue := apperrors.Classify(err)
		return ConnectionResult{
			Success:   false,
			Message:   ue.Message,
			Code:      ue.Code,
			Retryable: ue.Retryable,
		}
	}

	a.mu.Lock()
	a.client = client
	a.connectCancel = nil
	debug.Println("[DEBUG] SSH connected, creating vellum client")
	a.vellumClient = vellum.NewClient(&wailsExecutor{app: a})
	a.mu.Unlock()

	if a.logger != nil {
		a.logger.LogConnection("connected", host)
	}

	debug.Println("[DEBUG] Detecting device...")
	deviceType, err := a.detectDevice()
	debug.Printf("[DEBUG] Device detected: %s, err: %v\n", deviceType, err)
	if err != nil {
		return ConnectionResult{
			Success: true,
			Message: "Connected (could not detect device type)",
			Device:  "unknown",
		}
	}

	go func() {
		a.mu.Lock()
		vc := a.vellumClient
		a.mu.Unlock()
		if vc == nil {
			return
		}

		if err := a.metadata.Refresh(); err != nil {
			debug.Printf("[DEBUG] Metadata refresh failed: %v\n", err)
		}

		debug.Println("[DEBUG] Checking if vellum is installed...")
		installed, err := vc.IsInstalled()
		debug.Printf("[DEBUG] Vellum installed: %v, err: %v\n", installed, err)

		warnings := map[string]interface{}{}
		vellumReady := false
		var osVersionStored string

		if err == nil && !installed {
			runtime.EventsEmit(a.ctx, "vellum:bootstrap-prompt", nil)
		} else if err == nil && installed {
			valid, missing, verr := vc.ValidateInstall()
			debug.Printf("[DEBUG] Vellum validation: valid=%v, missing=%v, err=%v\n", valid, missing, verr)
			runtime.EventsEmit(a.ctx, "vellum:ready", nil)
			if verr == nil && !valid {
				runtime.EventsEmit(a.ctx, "vellum:broken-install", missing)
			} else {
				vellumReady = true

				reenableStatus, reenableErr := vc.ReenableStatus()
				if reenableErr == nil && reenableStatus != "" {
					debug.Printf("[DEBUG] Reenable status: %s\n", reenableStatus)
					warnings["reenableStatus"] = reenableStatus
				}
			}
		}

		hashtabStatus := a.CheckHashtabVersion()
		debug.Printf("[DEBUG] Hashtab check: installed=%v, hashtabVersion=%s, firmwareVersion=%s, needsRebuild=%v\n",
			hashtabStatus.Installed, hashtabStatus.HashtabVersion, hashtabStatus.FirmwareVersion, hashtabStatus.NeedsRebuild)
		if hashtabStatus.NeedsRebuild {
			warnings["hashtabMismatch"] = hashtabStatus
		}

		var installedVersions map[string]string
		if vellumReady {
			installedVersions, _ = vc.ListInstalledWithVersions()
		}

		if !hashtabStatus.Installed && installedVersions != nil {
			if _, hasQRB := installedVersions["qt-resource-rebuilder"]; hasQRB {
				warnings["hashtabMissing"] = true
			}
		}

		updateStatus := a.GetUpdateServiceStatus()
		debug.Printf("[DEBUG] Auto-update check: enabled=%v, running=%v\n", updateStatus.Enabled, updateStatus.Running)
		if updateStatus.Enabled || updateStatus.Running {
			warnings["autoUpdateEnabled"] = updateStatus
		}

		xochitlStatus := a.GetXochitlStatus()
		debug.Printf("[DEBUG] Xochitl check: running=%v, xoviActive=%v\n", xochitlStatus.Running, xochitlStatus.XoviActive)
		if !xochitlStatus.Running {
			warnings["xochitlNotRunning"] = true
		}
		if xochitlStatus.Running && !xochitlStatus.XoviActive && !hashtabStatus.NeedsRebuild && hashtabStatus.Installed && installedVersions != nil {
			if _, hasXovi := installedVersions["xovi"]; hasXovi {
				warnings["xoviNotRunning"] = true
			}
		}

		timezoneStatus := a.GetTimezoneStatus()
		debug.Printf("[DEBUG] Timezone check: device=%s, saved=%s, needsUpdate=%v\n",
			timezoneStatus.DeviceTimezone, timezoneStatus.SavedTimezone, timezoneStatus.NeedsUpdate)

		if timezoneStatus.DeviceTimezone != "" && timezoneStatus.SavedTimezone == "" {
			a.mu.Lock()
			deviceID := a.connectedDeviceID
			a.mu.Unlock()
			if deviceID != "" && a.deviceStore != nil {
				if err := a.deviceStore.UpdateTimezone(deviceID, timezoneStatus.DeviceTimezone); err == nil {
					debug.Printf("[DEBUG] Auto-saved device timezone: %s\n", timezoneStatus.DeviceTimezone)
					timezoneStatus.SavedTimezone = timezoneStatus.DeviceTimezone
				}
			}
		}
		if timezoneStatus.DeviceTimezone != "" {
			warnings["timezoneStatus"] = timezoneStatus
		}
		if timezoneStatus.NeedsUpdate {
			warnings["timezoneMismatch"] = timezoneStatus
		}

		if vellumReady {
			settings, _ := a.settingsStore.Load()
			proxyEnabled := settings == nil || settings.ProxyMode

			if proxyEnabled {
				a.mu.Lock()
				sshClient := a.client
				a.mu.Unlock()
				if sshClient != nil {
					arch := device.GetArchitecture(component.DeviceType(deviceType))
					proxy := vellum.NewProxy(vc, sshClient, string(arch))
					_ = proxy.UploadAPKINDEX(func(msg string) {
						debug.Printf("[DEBUG] Upgrade check APKINDEX: %s\n", msg)
					})
				}
			}

			upgradeResult, simErr := vc.SimulateUpgrade()

			osState, err := vc.GetOSVersionState()
			debug.Printf("[DEBUG] GetOSVersionState: stored=%q, current=%q, mismatch=%v, err=%v\n", osState.StoredVersion, osState.CurrentVersion, osState.Mismatch, err)
			if err == nil {
				osVersionStored = osState.StoredVersion
			}
			if err == nil && osState.Mismatch {
				debug.Printf("[DEBUG] OS mismatch detected: stored=%s, current=%s\n",
					osState.StoredVersion, osState.CurrentVersion)
				warnings["osMismatch"] = map[string]string{
					"prevVersion": osState.StoredVersion,
					"newVersion":  osState.CurrentVersion,
				}
			}

			if simErr == nil && upgradeResult.HasUpgrades {
				if _, hasMismatch := warnings["osMismatch"]; !hasMismatch {
					runtime.EventsEmit(a.ctx, "packages:upgrades-available", map[string]interface{}{
						"packages": upgradeResult.Packages,
					})
				}
			}
		}

		if a.deviceInfoCache != nil {
			a.mu.Lock()
			cacheDeviceID := a.connectedDeviceID
			a.mu.Unlock()
			if cacheDeviceID != "" {
				cached := storage.CachedDeviceInfo{
					Timezone:             timezoneStatus.DeviceTimezone,
					HashtabInstalled:     hashtabStatus.Installed,
					HashtabVersion:       hashtabStatus.HashtabVersion,
					HashtabNeedsRebuild:  hashtabStatus.NeedsRebuild,
					UpdateServiceEnabled: updateStatus.Enabled,
					UpdateServiceRunning: updateStatus.Running,
					OSVersion:            osVersionStored,
					CachedAt:             time.Now().Unix(),
				}
				if devInfo := a.GetDeviceInfo(); len(devInfo) > 0 {
					cached.MachineType = devInfo["machine"]
					cached.FirmwareVersion = devInfo["firmware"]
				}
				if vc != nil {
					if versions, err := vc.ListInstalledWithVersions(); err == nil {
						cached.InstalledPackages = versions
					}
				}
				if partInfo, err := a.GetPartitionInfo(); err == nil {
					cached.PartitionInfo = partInfo
				}
				if err := a.deviceInfoCache.Set(cacheDeviceID, cached); err != nil {
					debug.Printf("[DEBUG] Failed to cache device info: %v\n", err)
				}
			}
		}

		runtime.EventsEmit(a.ctx, "connect:warnings", warnings)
	}()

	a.mu.Lock()
	a.connectedDeviceType = deviceType
	a.mu.Unlock()

	return ConnectionResult{
		Success: true,
		Message: "Connected successfully",
		Device:  deviceType,
	}
}

func (a *App) detectDevice() (string, error) {
	output, err := a.runCommand("cat /sys/devices/soc0/machine")
	if err != nil {
		return "", err
	}

	machine := strings.TrimSpace(output)
	switch {
	case strings.Contains(machine, "reMarkable 1"):
		return "rm1", nil
	case strings.Contains(machine, "reMarkable 2"):
		return "rm2", nil
	case strings.Contains(machine, "Ferrari"):
		return "rmpp", nil
	case strings.Contains(machine, "Chiappa"):
		return "rmppm", nil
	default:
		return machine, nil
	}
}

func (a *App) Disconnect() {
	if a.logger != nil {
		a.logger.LogConnection("disconnect", "user initiated")
	}

	a.stopConnectionMonitor()

	a.reconnectMu.Lock()
	a.reconnecting = false
	a.reconnectMu.Unlock()

	a.StopPreventSleep()
	a.StopShell()

	a.mu.Lock()
	defer a.mu.Unlock()

	a.connectedDeviceID = ""
	a.connectedDeviceType = ""
	a.writeableRootBusy = false

	if a.client != nil {
		a.client.Close()
		a.client = nil
	}
	if a.agentConn != nil {
		a.agentConn.Close()
		a.agentConn = nil
	}
	a.vellumClient = nil
}

func (a *App) IsConnected() bool {
	a.mu.Lock()
	defer a.mu.Unlock()
	return a.client != nil
}

func (a *App) acquireWriteableRoot(deviceType string) error {
	dev := component.DeviceType(deviceType)
	if dev != component.DeviceRMPP && dev != component.DeviceRMPPM {
		return nil
	}
	a.mu.Lock()
	defer a.mu.Unlock()
	if a.writeableRootBusy {
		return fmt.Errorf("another operation is modifying the filesystem")
	}
	a.writeableRootBusy = true
	runtime.EventsEmit(a.ctx, "writeable-root:busy", true)
	return nil
}

func (a *App) releaseWriteableRoot(deviceType string) {
	dev := component.DeviceType(deviceType)
	if dev != component.DeviceRMPP && dev != component.DeviceRMPPM {
		return
	}
	a.mu.Lock()
	defer a.mu.Unlock()
	a.writeableRootBusy = false
	runtime.EventsEmit(a.ctx, "writeable-root:busy", false)
}

func (a *App) IsWriteableRootBusy() bool {
	a.mu.Lock()
	defer a.mu.Unlock()
	return a.writeableRootBusy
}

const (
	keepaliveInterval    = 15 * time.Second
	keepaliveTimeout     = 5 * time.Second
	maxReconnectAttempts = 5
)

var reconnectBackoff = []time.Duration{
	2 * time.Second,
	4 * time.Second,
	8 * time.Second,
	16 * time.Second,
	30 * time.Second,
}

func (a *App) startConnectionMonitor() {
	a.mu.Lock()
	if a.keepaliveStop != nil {
		a.mu.Unlock()
		return
	}
	a.keepaliveStop = make(chan struct{})
	a.mu.Unlock()

	go a.connectionMonitorLoop()
}

func (a *App) stopConnectionMonitor() {
	a.mu.Lock()
	if a.keepaliveStop != nil {
		close(a.keepaliveStop)
		a.keepaliveStop = nil
	}
	a.mu.Unlock()
}

func (a *App) connectionMonitorLoop() {
	ticker := time.NewTicker(keepaliveInterval)
	defer ticker.Stop()

	a.mu.Lock()
	stopCh := a.keepaliveStop
	a.mu.Unlock()

	for {
		select {
		case <-stopCh:
			return
		case <-ticker.C:
			if err := a.checkConnection(); err != nil {
				a.handleConnectionLost(err)
				return
			}
		}
	}
}

func (a *App) checkConnection() error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("client is nil")
	}

	done := make(chan error, 1)
	go func() {
		_, _, err := client.SendRequest("keepalive@openssh.com", true, nil)
		done <- err
	}()

	select {
	case err := <-done:
		return err
	case <-time.After(keepaliveTimeout):
		return fmt.Errorf("keepalive timeout")
	}
}

func (a *App) handleConnectionLost(err error) {
	if a.logger != nil {
		a.logger.LogConnection("connection-lost", err.Error())
	}
	a.mu.Lock()
	hadCommandSession := a.commandSession != nil
	if a.commandSession != nil {
		a.commandSession.Close()
		a.commandSession = nil
		a.commandStdin = nil
	}
	if a.client != nil {
		a.client.Close()
		a.client = nil
	}
	if a.agentConn != nil {
		a.agentConn.Close()
		a.agentConn = nil
	}
	a.vellumClient = nil
	a.writeableRootBusy = false
	deviceID := a.connectedDeviceID
	a.keepaliveStop = nil
	a.mu.Unlock()

	if hadCommandSession {
		runtime.EventsEmit(a.ctx, "command:output", "\nConnection lost.\n")
	}

	ue := apperrors.Classify(err)
	runtime.EventsEmit(a.ctx, "connection:lost", map[string]interface{}{
		"reason":   ue.Message,
		"code":     ue.Code,
		"deviceId": deviceID,
	})

	if deviceID != "" {
		go a.attemptReconnect(deviceID)
	} else {
		runtime.EventsEmit(a.ctx, "connection:failed", map[string]interface{}{
			"reason":   "Connection lost. Manual reconnection required.",
			"code":     apperrors.ErrHostDown,
			"deviceId": "",
		})
	}
}

func (a *App) attemptReconnect(deviceID string) {
	debug.Printf("[%s] attemptReconnect started for device %s\n", time.Now().Format("15:04:05.000"), deviceID)

	a.reconnectMu.Lock()
	if a.reconnecting {
		a.reconnectMu.Unlock()
		debug.Printf("[%s] Already reconnecting, skipping\n", time.Now().Format("15:04:05.000"))
		return
	}
	a.reconnecting = true
	a.fastDialMode = true
	a.reconnectMu.Unlock()

	defer func() {
		a.reconnectMu.Lock()
		a.reconnecting = false
		a.fastDialMode = false
		a.reconnectMu.Unlock()
		debug.Printf("[%s] attemptReconnect finished\n", time.Now().Format("15:04:05.000"))
	}()

	for attempt := 0; attempt < maxReconnectAttempts; attempt++ {
		a.reconnectMu.Lock()
		stillReconnecting := a.reconnecting
		a.reconnectMu.Unlock()

		if !stillReconnecting {
			debug.Printf("[%s] Reconnect cancelled\n", time.Now().Format("15:04:05.000"))
			return
		}

		debug.Printf("[%s] Reconnect attempt %d/%d starting\n", time.Now().Format("15:04:05.000"), attempt+1, maxReconnectAttempts)

		runtime.EventsEmit(a.ctx, "connection:reconnecting", map[string]interface{}{
			"attempt":     attempt + 1,
			"maxAttempts": maxReconnectAttempts,
			"deviceId":    deviceID,
		})

		result := a.ConnectToSavedDevice(deviceID)
		debug.Printf("[%s] Reconnect attempt %d/%d result: success=%v, message=%s\n", time.Now().Format("15:04:05.000"), attempt+1, maxReconnectAttempts, result.Success, result.Message)

		if result.Success {
			if a.logger != nil {
				a.logger.LogConnection("reconnected", deviceID)
			}
			runtime.EventsEmit(a.ctx, "connection:restored", map[string]interface{}{
				"deviceId": deviceID,
				"device":   result.Device,
			})
			return
		}

		if !isRetryableError(errors.New(result.Message)) {
			runtime.EventsEmit(a.ctx, "connection:failed", map[string]interface{}{
				"reason":   result.Message,
				"code":     result.Code,
				"deviceId": deviceID,
			})
			return
		}

		if attempt < maxReconnectAttempts-1 {
			backoffIdx := attempt
			if backoffIdx >= len(reconnectBackoff) {
				backoffIdx = len(reconnectBackoff) - 1
			}
			debug.Printf("[%s] Waiting %v before next attempt\n", time.Now().Format("15:04:05.000"), reconnectBackoff[backoffIdx])
			time.Sleep(reconnectBackoff[backoffIdx])
			debug.Printf("[%s] Backoff complete\n", time.Now().Format("15:04:05.000"))
		}
	}

	debug.Printf("[%s] All reconnect attempts exhausted\n", time.Now().Format("15:04:05.000"))
	runtime.EventsEmit(a.ctx, "connection:failed", map[string]interface{}{
		"reason":   "Could not reconnect after multiple attempts. Please check your connection and try again.",
		"code":     apperrors.ErrTimeout,
		"deviceId": deviceID,
	})
}

func (a *App) runCommand(cmd string) (string, error) {
	if a.client == nil {
		return "", fmt.Errorf("not connected")
	}

	debug.Printf("[DEBUG] runCommand creating session: %s\n", cmd[:min(50, len(cmd))])
	session, err := a.client.NewSession()
	if err != nil {
		debug.Printf("[DEBUG] runCommand session error: %v\n", err)
		return "", err
	}
	defer session.Close()

	debug.Printf("[DEBUG] runCommand executing: %s\n", cmd[:min(50, len(cmd))])
	output, err := session.CombinedOutput(cmd)
	debug.Printf("[DEBUG] runCommand done: %s, err: %v\n", cmd[:min(50, len(cmd))], err)
	return string(output), err
}

func (a *App) RunCommand(cmd string) string {
	a.mu.Lock()
	defer a.mu.Unlock()

	output, err := a.runCommand(cmd)
	if err != nil {
		return fmt.Sprintf("Error: %v\n%s", err, output)
	}
	return output
}

func (a *App) RunCommandWithOutput(cmd string, requiresPTY bool) {
	debug.Println("[DEBUG] RunCommandWithOutput called:", cmd[:min(50, len(cmd))], "requiresPTY:", requiresPTY)
	cmdLog := a.operationLog
	ownLog := cmdLog == nil
	if ownLog && a.logger != nil {
		cmdLog = a.logger.StartCommandLog(a.connectedDeviceID, cmd)
	}
	if !ownLog {
		cmdLog.Write(fmt.Sprintf("\n$ %s\n", cmd))
	}
	go func() {
		defer func() {
			if ownLog && cmdLog != nil {
				cmdLog.Close()
			}
		}()
		a.mu.Lock()

		if a.client == nil {
			a.mu.Unlock()
			debug.Println("[DEBUG] Not connected, emitting error")
			runtime.EventsEmit(a.ctx, "command:output", "Error: not connected\n")
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		session, err := a.client.NewSession()
		if err != nil {
			a.mu.Unlock()
			debug.Println("[DEBUG] Session error:", err)
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Error: %v\n", err))
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		if requiresPTY {
			err = session.RequestPty("xterm-256color", 40, 120, ssh.TerminalModes{
				ssh.ECHO:          1,
				ssh.TTY_OP_ISPEED: 14400,
				ssh.TTY_OP_OSPEED: 14400,
			})
			if err != nil {
				a.mu.Unlock()
				debug.Println("[DEBUG] PTY request error:", err)
				runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Error requesting PTY: %v\n", err))
				runtime.EventsEmit(a.ctx, "command:done", false)
				return
			}
			debug.Println("[DEBUG] PTY allocated successfully")
		}

		a.commandSession = session
		a.mu.Unlock()

		defer func() {
			session.Close()
			a.mu.Lock()
			a.commandSession = nil
			a.commandStdin = nil
			a.mu.Unlock()
		}()

		stdout, err := session.StdoutPipe()
		if err != nil {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Error: %v\n", err))
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		stderr, err := session.StderrPipe()
		if err != nil {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Error: %v\n", err))
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		stdin, err := session.StdinPipe()
		if err != nil {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Error: %v\n", err))
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		a.mu.Lock()
		a.commandStdin = stdin
		a.mu.Unlock()

		debug.Println("[DEBUG] Starting command")
		if err := session.Start(cmd); err != nil {
			debug.Println("[DEBUG] Start error:", err)
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Error: %v\n", err))
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		if !requiresPTY {
			stdin.Close()
		}

		go func() {
			buf := make([]byte, 1024)
			for {
				n, err := stdout.Read(buf)
				if n > 0 {
					debug.Printf("[DEBUG] stdout: %d bytes\n", n)
					chunk := string(buf[:n])
					runtime.EventsEmit(a.ctx, "command:output", chunk)
					cmdLog.Write(chunk)
				}
				if err == io.EOF {
					break
				}
				if err != nil {
					break
				}
			}
		}()

		go func() {
			buf := make([]byte, 1024)
			for {
				n, err := stderr.Read(buf)
				if n > 0 {
					debug.Printf("[DEBUG] stderr: %d bytes\n", n)
					chunk := string(buf[:n])
					runtime.EventsEmit(a.ctx, "command:output", chunk)
					cmdLog.Write(chunk)
				}
				if err == io.EOF {
					break
				}
				if err != nil {
					break
				}
			}
		}()

		err = session.Wait()
		if ownLog {
			cmdLog.WriteExitCode(err)
		}
		debug.Println("[DEBUG] Command done, success:", err == nil)
		runtime.EventsEmit(a.ctx, "command:done", err == nil)
	}()
}

func (a *App) StopCommand() {
	a.mu.Lock()
	stdin := a.commandStdin
	a.mu.Unlock()

	if stdin != nil {
		debug.Println("[DEBUG] Sending Ctrl+C (0x03) to stdin")
		_, err := stdin.Write([]byte{0x03})
		if err != nil {
			debug.Printf("[DEBUG] Error writing Ctrl+C to stdin: %v\n", err)
		} else {
			debug.Println("[DEBUG] Ctrl+C sent successfully")
		}
	} else {
		debug.Println("[DEBUG] No stdin available to send Ctrl+C")
	}
}

func (a *App) StartShell(rows, cols int) error {
	a.shellMu.Lock()
	defer a.shellMu.Unlock()

	if a.shellActive {
		return fmt.Errorf("shell already running")
	}

	a.mu.Lock()
	if a.client == nil {
		a.mu.Unlock()
		return fmt.Errorf("not connected")
	}

	session, err := a.client.NewSession()
	if err != nil {
		a.mu.Unlock()
		return fmt.Errorf("failed to create session: %w", err)
	}
	a.mu.Unlock()

	if rows <= 0 {
		rows = 24
	}
	if cols <= 0 {
		cols = 80
	}

	err = session.RequestPty("xterm-256color", rows, cols, ssh.TerminalModes{
		ssh.ECHO:          1,
		ssh.TTY_OP_ISPEED: 14400,
		ssh.TTY_OP_OSPEED: 14400,
	})
	if err != nil {
		session.Close()
		return fmt.Errorf("failed to request PTY: %w", err)
	}

	stdout, err := session.StdoutPipe()
	if err != nil {
		session.Close()
		return fmt.Errorf("failed to get stdout: %w", err)
	}

	stdin, err := session.StdinPipe()
	if err != nil {
		session.Close()
		return fmt.Errorf("failed to get stdin: %w", err)
	}

	if err := session.Shell(); err != nil {
		session.Close()
		return fmt.Errorf("failed to start shell: %w", err)
	}

	a.shellSession = session
	a.shellStdin = stdin
	a.shellActive = true

	runtime.EventsEmit(a.ctx, "shell:started")

	go func() {
		buf := make([]byte, 4096)
		for {
			n, err := stdout.Read(buf)
			if n > 0 {
				runtime.EventsEmit(a.ctx, "shell:output", string(buf[:n]))
			}
			if err != nil {
				break
			}
		}

		a.shellMu.Lock()
		a.shellActive = false
		a.shellSession = nil
		a.shellStdin = nil
		a.shellMu.Unlock()

		runtime.EventsEmit(a.ctx, "shell:stopped")
	}()

	return nil
}

func (a *App) WriteToShell(data string) error {
	a.shellMu.Lock()
	stdin := a.shellStdin
	a.shellMu.Unlock()

	if stdin == nil {
		return fmt.Errorf("shell not active")
	}

	_, err := stdin.Write([]byte(data))
	return err
}

func (a *App) ResizeShell(rows, cols int) error {
	a.shellMu.Lock()
	session := a.shellSession
	a.shellMu.Unlock()

	if session == nil {
		return fmt.Errorf("shell not active")
	}

	return session.WindowChange(rows, cols)
}

func (a *App) StopShell() {
	a.shellMu.Lock()
	session := a.shellSession
	stdin := a.shellStdin
	a.shellMu.Unlock()

	if session != nil {
		session.Signal(ssh.SIGHUP)
	}
	if stdin != nil {
		stdin.Close()
	}
	if session != nil {
		session.Close()
	}
}

func (a *App) IsShellActive() bool {
	a.shellMu.Lock()
	defer a.shellMu.Unlock()
	return a.shellActive
}

func (a *App) GetDeviceInfo() map[string]string {
	a.mu.Lock()

	info := make(map[string]string)

	if a.client == nil {
		a.mu.Unlock()
		return info
	}

	if output, err := a.runCommand("cat /sys/devices/soc0/machine"); err == nil {
		info["machine"] = strings.TrimSpace(output)
	}

	if output, err := a.runCommand("grep REMARKABLE_RELEASE_VERSION /usr/share/remarkable/update.conf"); err == nil {
		if parts := strings.SplitN(output, "=", 2); len(parts) == 2 {
			info["firmware"] = strings.TrimSpace(parts[1])
		}
	} else if output, err := a.runCommand("grep IMG_VERSION /etc/os-release"); err == nil {
		if parts := strings.SplitN(output, "=", 2); len(parts) == 2 {
			info["firmware"] = strings.Trim(strings.TrimSpace(parts[1]), "\"")
		}
	}

	vellumClient := a.vellumClient
	a.mu.Unlock()

	if vellumClient != nil {
		installed, _ := vellumClient.IsInstalled()
		if installed {
			info["vellum_installed"] = "yes"
		} else {
			info["vellum_installed"] = "no"
		}
	}

	return info
}

type UpdateServiceStatus struct {
	Enabled bool `json:"enabled"`
	Running bool `json:"running"`
}

func (a *App) GetUpdateServiceStatus() UpdateServiceStatus {
	a.mu.Lock()
	defer a.mu.Unlock()

	status := UpdateServiceStatus{
		Enabled: false,
		Running: false,
	}

	if a.client == nil {
		debug.Println("[DEBUG] GetUpdateServiceStatus: client is nil")
		return status
	}

	output, err := a.runCommand("systemctl is-enabled update-engine.service")
	debug.Printf("[DEBUG] GetUpdateServiceStatus: is-enabled output=%q, err=%v\n", output, err)
	if err == nil {
		status.Enabled = strings.TrimSpace(output) == "enabled"
	}

	output, err = a.runCommand("systemctl is-active update-engine.service")
	debug.Printf("[DEBUG] GetUpdateServiceStatus: is-active output=%q, err=%v\n", output, err)
	if err == nil {
		status.Running = strings.TrimSpace(output) == "active"
	}

	debug.Printf("[DEBUG] GetUpdateServiceStatus: returning enabled=%v, running=%v\n", status.Enabled, status.Running)
	return status
}

type XochitlStatus struct {
	Running    bool `json:"running"`
	XoviActive bool `json:"xoviActive"`
}

func (a *App) GetXochitlStatus() XochitlStatus {
	a.mu.Lock()
	defer a.mu.Unlock()

	if a.client == nil {
		return XochitlStatus{}
	}

	output, err := a.runCommand("systemctl is-active xochitl")
	running := err == nil && strings.TrimSpace(output) == "active"

	_, err = a.runCommand("test -f /etc/systemd/system/xochitl.service.d/00-xovi.conf")
	xoviActive := err == nil

	return XochitlStatus{Running: running, XoviActive: xoviActive}
}

type HashtabVersionStatus struct {
	Installed       bool   `json:"installed"`
	HashtabVersion  string `json:"hashtabVersion"`
	FirmwareVersion string `json:"firmwareVersion"`
	NeedsRebuild    bool   `json:"needsRebuild"`
}

func (a *App) CheckHashtabVersion() HashtabVersionStatus {
	status := HashtabVersionStatus{}

	a.mu.Lock()
	if a.client == nil {
		a.mu.Unlock()
		return status
	}

	if output, err := a.runCommand("grep REMARKABLE_RELEASE_VERSION /usr/share/remarkable/update.conf"); err == nil {
		if parts := strings.SplitN(output, "=", 2); len(parts) == 2 {
			status.FirmwareVersion = strings.TrimSpace(parts[1])
		}
	} else if output, err := a.runCommand("grep IMG_VERSION /etc/os-release"); err == nil {
		if parts := strings.SplitN(output, "=", 2); len(parts) == 2 {
			status.FirmwareVersion = strings.Trim(strings.TrimSpace(parts[1]), "\"")
		}
	}
	a.mu.Unlock()

	checker := vellum.NewHashtabChecker(&wailsExecutor{app: a})

	exists, err := checker.CheckHashtabExists()
	if err != nil || !exists {
		return status
	}
	status.Installed = true

	hashtabVersion, err := checker.GetHashtabVersion()
	if err != nil {
		return status
	}
	status.HashtabVersion = hashtabVersion

	status.NeedsRebuild = status.FirmwareVersion != "" &&
		status.HashtabVersion != "" &&
		status.FirmwareVersion != status.HashtabVersion

	return status
}

type TimezoneStatus struct {
	DeviceTimezone string `json:"deviceTimezone"`
	SavedTimezone  string `json:"savedTimezone"`
	NeedsUpdate    bool   `json:"needsUpdate"`
}

func (a *App) GetDeviceTimezone() (string, error) {
	a.mu.Lock()
	defer a.mu.Unlock()

	if a.client == nil {
		return "", fmt.Errorf("not connected")
	}

	output, err := a.runCommand("timedatectl show --property=Timezone --value")
	if err != nil {
		return "", fmt.Errorf("failed to get timezone: %w", err)
	}

	return strings.TrimSpace(output), nil
}

func (a *App) GetTimezoneStatus() TimezoneStatus {
	status := TimezoneStatus{}

	a.mu.Lock()
	if a.client == nil {
		a.mu.Unlock()
		return status
	}

	output, err := a.runCommand("timedatectl show --property=Timezone --value")
	if err != nil {
		a.mu.Unlock()
		return status
	}
	status.DeviceTimezone = strings.TrimSpace(output)

	deviceID := a.connectedDeviceID
	a.mu.Unlock()

	if deviceID != "" && a.deviceStore != nil {
		device, err := a.deviceStore.Get(deviceID)
		if err == nil && device.Timezone != "" {
			status.SavedTimezone = device.Timezone
			status.NeedsUpdate = device.Timezone != status.DeviceTimezone
		}
	}

	return status
}

func (a *App) SaveDeviceTimezone(timezone string) error {
	a.mu.Lock()
	deviceID := a.connectedDeviceID
	a.mu.Unlock()

	if deviceID == "" {
		return fmt.Errorf("no device connected")
	}
	if a.deviceStore == nil {
		return fmt.Errorf("device store not initialized")
	}

	return a.deviceStore.UpdateTimezone(deviceID, timezone)
}

func (a *App) SetDeviceTimezone(timezone string, deviceType string) {
	go func() {
		a.mu.Lock()
		if a.client == nil {
			a.mu.Unlock()
			runtime.EventsEmit(a.ctx, "timezone:error", "Not connected")
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}
		a.mu.Unlock()

		if err := a.acquireWriteableRoot(deviceType); err != nil {
			runtime.EventsEmit(a.ctx, "timezone:error", err.Error())
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}
		defer a.releaseWriteableRoot(deviceType)

		cmdResults := []component.CommandResult{
			{
				Script:      fmt.Sprintf("systemctl restart systemd-timedated && timedatectl set-timezone %s", timezone),
				Description: "Set device timezone",
			},
		}

		dev := component.DeviceType(deviceType)
		if dev == component.DeviceRMPP || dev == component.DeviceRMPPM {
			cmdResults = commands.WrapWithWriteableRoot(cmdResults, dev)
		}

		var operationErr error
		if a.logger != nil {
			a.operationLog = a.logger.StartCommandLog(a.connectedDeviceID, "set-timezone")
			defer func() {
				a.operationLog.WriteExitCode(operationErr)
				a.operationLog.Close()
				a.operationLog = nil
			}()
		}

		for _, cmd := range cmdResults {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", cmd.Script))

			done := make(chan bool, 1)
			unsub := runtime.EventsOn(a.ctx, "command:done", func(optionalData ...interface{}) {
				if len(optionalData) > 0 {
					if success, ok := optionalData[0].(bool); ok {
						done <- success
						return
					}
				}
				done <- false
			})

			a.RunCommandWithOutput(cmd.Script, cmd.RequiresPTY)
			success := <-done
			unsub()

			if !success {
				operationErr = fmt.Errorf("command failed: %s", cmd.Script)
				runtime.EventsEmit(a.ctx, "timezone:error", "Failed to set timezone")
				return
			}
		}

		runtime.EventsEmit(a.ctx, "timezone:complete", timezone)
	}()
}

type PackageInfo struct {
	Name           string                `json:"name"`
	Version        string                `json:"version"`
	Description    string                `json:"description"`
	UpstreamAuthor string                `json:"upstreamAuthor"`
	Categories     []string              `json:"categories"`
	URL            string                `json:"url"`
	License        string                `json:"license"`
	Devices        []string              `json:"devices"`
	Depends        []string              `json:"depends"`
	Conflicts      []string              `json:"conflicts"`
	OSMin          *string               `json:"osMin"`
	OSMax          *string               `json:"osMax"`
	OSConstraints  []vellum.OSConstraint `json:"osConstraints"`
	Compatible     bool                  `json:"compatible"`
}

var hiddenPackages = map[string]bool{
	"vellum":                 true,
	"vellum-bash-completion": true,
	"mount-utils":            true,
	"/bin/sh":                true,
}

func containsString(slice []string, s string) bool {
	for _, v := range slice {
		if v == s {
			return true
		}
	}
	return false
}

func (a *App) RefreshMetadata() error {
	return a.metadata.Refresh()
}

func (a *App) GetPackages(deviceType, firmware, arch string) []PackageInfo {
	debug.Printf("[DEBUG] GetPackages called, metadata=%p, deviceType=%s, firmware=%s, arch=%s\n", a.metadata, deviceType, firmware, arch)
	packages := a.metadata.GetAllPackagesForDevice(deviceType, firmware, arch)
	debug.Printf("[DEBUG] GetPackages got %d packages\n", len(packages))
	result := []PackageInfo{}

	for _, pkg := range packages {
		if hiddenPackages[pkg.Name] {
			continue
		}
		var visibleDepends []string
		for _, dep := range pkg.Depends {
			if !hiddenPackages[dep] {
				visibleDepends = append(visibleDepends, dep)
			}
		}
		result = append(result, PackageInfo{
			Name:           pkg.Name,
			Version:        pkg.Version,
			Description:    pkg.Description,
			UpstreamAuthor: pkg.UpstreamAuthor,
			Categories:     pkg.Categories,
			URL:            pkg.URL,
			License:        pkg.License,
			Devices:        pkg.Devices,
			Depends:        visibleDepends,
			Conflicts:      pkg.Conflicts,
			OSMin:          pkg.OSMin,
			OSMax:          pkg.OSMax,
			OSConstraints:  pkg.OSConstraints,
			Compatible:     pkg.Compatible,
		})
	}

	debug.Printf("[DEBUG] GetPackages returning %d PackageInfo\n", len(result))
	return result
}

func (a *App) GetInstalledPackages() []string {
	if a.vellumClient == nil {
		return []string{}
	}

	packages, err := a.vellumClient.List()
	if err != nil {
		fmt.Printf("Error getting installed packages: %v\n", err)
		return []string{}
	}

	var result []string
	for _, pkg := range packages {
		if !hiddenPackages[pkg] {
			result = append(result, pkg)
		}
	}
	return result
}

type InstalledPackagesResult struct {
	Packages    []string `json:"packages"`
	OsUpgraded  bool     `json:"osUpgraded"`
	PrevVersion string   `json:"prevVersion"`
	NewVersion  string   `json:"newVersion"`
}

func (a *App) GetInstalledPackagesWithOsCheck() InstalledPackagesResult {
	if a.vellumClient == nil {
		return InstalledPackagesResult{}
	}

	listResult, err := a.vellumClient.ListWithOsCheck()
	if err != nil {
		fmt.Printf("Error getting installed packages: %v\n", err)
		return InstalledPackagesResult{}
	}

	var packages []string
	for _, pkg := range listResult.Packages {
		if !hiddenPackages[pkg] {
			packages = append(packages, pkg)
		}
	}

	return InstalledPackagesResult{
		Packages:    packages,
		OsUpgraded:  listResult.OsUpgraded,
		PrevVersion: listResult.PrevVersion,
		NewVersion:  listResult.NewVersion,
	}
}

func (a *App) GetInstalledPackagesWithVersions() map[string]string {
	if a.vellumClient == nil {
		return map[string]string{}
	}

	versions, err := a.vellumClient.ListInstalledWithVersions()
	if err != nil {
		fmt.Printf("Error getting installed packages with versions: %v\n", err)
		return map[string]string{}
	}

	result := make(map[string]string)
	for pkg, version := range versions {
		if !hiddenPackages[pkg] {
			result[pkg] = version
		}
	}
	return result
}

func (a *App) GetPackageForOS(name, targetOS, deviceType, arch string) *PackageInfo {
	if a.metadata == nil {
		return nil
	}

	pkg := a.metadata.GetPackageForTargetOS(name, targetOS, deviceType, arch)
	if pkg == nil {
		return nil
	}

	return &PackageInfo{
		Name:           pkg.Name,
		Version:        pkg.Version,
		Description:    pkg.Description,
		UpstreamAuthor: pkg.UpstreamAuthor,
		Categories:     pkg.Categories,
		URL:            pkg.URL,
		License:        pkg.License,
		Devices:        pkg.Devices,
		Depends:        pkg.Depends,
		Conflicts:      pkg.Conflicts,
		OSMin:          pkg.OSMin,
		OSMax:          pkg.OSMax,
		OSConstraints:  pkg.OSConstraints,
	}
}

func (a *App) RunReenable() {
	if a.vellumClient == nil {
		return
	}

	if err := a.acquireWriteableRoot(a.connectedDeviceType); err != nil {
		runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Blocked: %v\n", err))
		return
	}
	defer a.releaseWriteableRoot(a.connectedDeviceType)

	runtime.EventsEmit(a.ctx, "command:output", "Running vellum reenable...\n")

	err := a.vellumClient.ReenableStreaming(func(line string) {
		runtime.EventsEmit(a.ctx, "command:output", line+"\n")
	})

	if err != nil {
		runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("\nError: %v\n", err))
	} else {
		runtime.EventsEmit(a.ctx, "command:output", "\nReenable completed successfully.\n")
	}
}

type ReenableStatusResult struct {
	Status string `json:"status"`
}

func (a *App) GetReenableStatus() ReenableStatusResult {
	if a.vellumClient == nil {
		return ReenableStatusResult{}
	}
	status, err := a.vellumClient.ReenableStatus()
	if err != nil {
		debug.Printf("[DEBUG] GetReenableStatus error: %v\n", err)
		return ReenableStatusResult{}
	}
	debug.Printf("[DEBUG] GetReenableStatus: %s\n", status)
	return ReenableStatusResult{Status: status}
}

func (a *App) SimulatePackageUpgrade() (map[string]interface{}, error) {
	if a.vellumClient == nil {
		return nil, fmt.Errorf("not connected")
	}
	result, err := a.vellumClient.SimulateUpgrade()
	if err != nil {
		return nil, err
	}
	return map[string]interface{}{
		"packages":    result.Packages,
		"hasUpgrades": result.HasUpgrades,
	}, nil
}

func (a *App) RunPackageUpgrade() {
	go func() {
		a.mu.Lock()
		vc := a.vellumClient
		sshClient := a.client
		dt := a.connectedDeviceType
		a.mu.Unlock()
		if vc == nil {
			return
		}

		settings, _ := a.settingsStore.Load()
		proxyEnabled := settings == nil || settings.ProxyMode

		if proxyEnabled && sshClient != nil {
			arch := device.GetArchitecture(component.DeviceType(dt))
			proxy := vellum.NewProxy(vc, sshClient, string(arch))
			runtime.EventsEmit(a.ctx, "command:output", "Downloading upgrade packages via reManager...\n")
			err := proxy.ProxyUpgradeDownload(func(progress vellum.ProxyProgress) {
				runtime.EventsEmit(a.ctx, "command:output", progress.Message+"\n")
			})
			if err != nil {
				runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("\nProxy download failed: %v\n", err))
				runtime.EventsEmit(a.ctx, "package-upgrade:complete", map[string]interface{}{
					"success":  false,
					"dnsError": false,
				})
				return
			}
		}

		runtime.EventsEmit(a.ctx, "command:output", "Running vellum upgrade...\n")

		var dnsError bool
		err := vc.UpgradeStreaming(func(line string) {
			runtime.EventsEmit(a.ctx, "command:output", line+"\n")
			if strings.Contains(strings.ToLower(line), "dns:") {
				dnsError = true
			}
		})

		success := err == nil
		if success {
			runtime.EventsEmit(a.ctx, "command:output", "\nPackage upgrade completed.\n")
		} else {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("\nUpgrade error: %v\n", err))
		}
		runtime.EventsEmit(a.ctx, "package-upgrade:complete", map[string]interface{}{
			"success":  success,
			"dnsError": dnsError,
		})
	}()
}

type OSVersionStateResult struct {
	CurrentVersion string `json:"currentVersion"`
	StoredVersion  string `json:"storedVersion"`
	Mismatch       bool   `json:"mismatch"`
}

func (a *App) GetOSVersionState() OSVersionStateResult {
	if a.vellumClient == nil {
		return OSVersionStateResult{}
	}

	state, err := a.vellumClient.GetOSVersionState()
	if err != nil {
		return OSVersionStateResult{}
	}

	return OSVersionStateResult{
		CurrentVersion: state.CurrentVersion,
		StoredVersion:  state.StoredVersion,
		Mismatch:       state.Mismatch,
	}
}

type CompatibilityResultJSON struct {
	Compatible   []string `json:"compatible"`
	Incompatible []string `json:"incompatible"`
	NoConstraint []string `json:"noConstraint"`
	FetchFailed  bool     `json:"fetchFailed"`
}

func (a *App) CheckOSCompatibility(targetOS string) CompatibilityResultJSON {
	if a.vellumClient == nil {
		return CompatibilityResultJSON{FetchFailed: true}
	}

	result, _ := a.vellumClient.CheckOSCompatibility(targetOS)
	if result == nil {
		return CompatibilityResultJSON{FetchFailed: true}
	}

	return CompatibilityResultJSON{
		Compatible:   result.Compatible,
		Incompatible: result.Incompatible,
		NoConstraint: result.NoConstraint,
		FetchFailed:  result.FetchFailed,
	}
}

type PackageCompatibilityStatus struct {
	InstalledPackages    []string          `json:"installedPackages"`
	CompatiblePackages   []string          `json:"compatiblePackages"`
	IncompatiblePackages []string          `json:"incompatiblePackages"`
	CurrentOsVersion     string            `json:"currentOsVersion"`
	StoredOsVersion      string            `json:"storedOsVersion"`
	FetchFailed          bool              `json:"fetchFailed"`
}

func (a *App) GetPackageCompatibilityStatus() PackageCompatibilityStatus {
	debug.Println("[DEBUG] GetPackageCompatibilityStatus: called")
	if a.vellumClient == nil {
		debug.Println("[DEBUG] GetPackageCompatibilityStatus: vellumClient is nil")
		return PackageCompatibilityStatus{FetchFailed: true}
	}

	osState, err := a.vellumClient.GetOSVersionState()
	if err != nil {
		debug.Printf("[DEBUG] GetPackageCompatibilityStatus: GetOSVersionState error: %v\n", err)
		return PackageCompatibilityStatus{FetchFailed: true}
	}
	debug.Printf("[DEBUG] GetPackageCompatibilityStatus: osState=%+v\n", osState)

	installed, err := a.vellumClient.List()
	if err != nil {
		debug.Printf("[DEBUG] GetPackageCompatibilityStatus: List error: %v\n", err)
		return PackageCompatibilityStatus{FetchFailed: true}
	}
	debug.Printf("[DEBUG] GetPackageCompatibilityStatus: installed=%v\n", installed)

	var filteredInstalled []string
	for _, pkg := range installed {
		if !hiddenPackages[pkg] {
			filteredInstalled = append(filteredInstalled, pkg)
		}
	}
	debug.Printf("[DEBUG] GetPackageCompatibilityStatus: filteredInstalled=%v\n", filteredInstalled)

	compat, err := a.vellumClient.CheckOSCompatibility(osState.CurrentVersion)
	debug.Printf("[DEBUG] GetPackageCompatibilityStatus: compat=%+v, err=%v\n", compat, err)

	if err != nil && (compat == nil || compat.FetchFailed) {
		debug.Println("[DEBUG] GetPackageCompatibilityStatus: returning with FetchFailed due to error")
		return PackageCompatibilityStatus{
			InstalledPackages: filteredInstalled,
			CurrentOsVersion:  osState.CurrentVersion,
			StoredOsVersion:   osState.StoredVersion,
			FetchFailed:       true,
		}
	}

	allEmpty := len(compat.Compatible) == 0 && len(compat.Incompatible) == 0 && len(compat.NoConstraint) == 0
	if compat.FetchFailed || allEmpty {
		debug.Printf("[DEBUG] GetPackageCompatibilityStatus: fallback (FetchFailed=%v, allEmpty=%v)\n", compat.FetchFailed, allEmpty)
		return PackageCompatibilityStatus{
			InstalledPackages:    filteredInstalled,
			CompatiblePackages:   filteredInstalled,
			IncompatiblePackages: []string{},
			CurrentOsVersion:     osState.CurrentVersion,
			StoredOsVersion:      osState.StoredVersion,
			FetchFailed:          true,
		}
	}

	result := PackageCompatibilityStatus{
		InstalledPackages:    filteredInstalled,
		CompatiblePackages:   append(compat.Compatible, compat.NoConstraint...),
		IncompatiblePackages: compat.Incompatible,
		CurrentOsVersion:     osState.CurrentVersion,
		StoredOsVersion:      osState.StoredVersion,
		FetchFailed:          false,
	}
	debug.Printf("[DEBUG] GetPackageCompatibilityStatus: returning result=%+v\n", result)
	return result
}

func (a *App) RunUpgrade() {
	go func() {
		a.mu.Lock()
		vc := a.vellumClient
		a.mu.Unlock()
		if vc == nil {
			return
		}

		osState, err := vc.GetOSVersionState()
		if err != nil {
			runtime.EventsEmit(a.ctx, "upgrade:error", "Failed to get OS version state")
			return
		}

		if osState.Mismatch {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Checking package compatibility with OS %s...\n", osState.CurrentVersion))

			compat, err := vc.CheckOSCompatibility(osState.CurrentVersion)
			if err != nil && compat.FetchFailed {
				runtime.EventsEmit(a.ctx, "upgrade:error", "Could not fetch package index to verify compatibility")
				return
			}

			if len(compat.Incompatible) > 0 {
				runtime.EventsEmit(a.ctx, "upgrade:blocked", CompatibilityResultJSON{
					Compatible:   compat.Compatible,
					Incompatible: compat.Incompatible,
					NoConstraint: compat.NoConstraint,
					FetchFailed:  compat.FetchFailed,
				})
				return
			}

			runtime.EventsEmit(a.ctx, "command:output", "All packages compatible. Proceeding with upgrade...\n\n")
		}

		settings, _ := a.settingsStore.Load()
		proxyEnabled := settings == nil || settings.ProxyMode

		a.mu.Lock()
		sshClient := a.client
		dt := a.connectedDeviceType
		a.mu.Unlock()

		if proxyEnabled && sshClient != nil {
			arch := device.GetArchitecture(component.DeviceType(dt))
			proxy := vellum.NewProxy(vc, sshClient, string(arch))
			runtime.EventsEmit(a.ctx, "command:output", "Downloading upgrade packages via reManager...\n")
			proxyErr := proxy.ProxyUpgradeDownload(func(progress vellum.ProxyProgress) {
				runtime.EventsEmit(a.ctx, "command:output", progress.Message+"\n")
			})
			if proxyErr != nil {
				runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("\nProxy download failed: %v\n", proxyErr))
				runtime.EventsEmit(a.ctx, "upgrade:complete", map[string]interface{}{
					"success":  false,
					"dnsError": false,
				})
				return
			}
		}

		runtime.EventsEmit(a.ctx, "command:output", "Running vellum upgrade...\n")

		var dnsError bool
		err = vc.UpgradeStreaming(func(line string) {
			runtime.EventsEmit(a.ctx, "command:output", line+"\n")
			if strings.Contains(strings.ToLower(line), "dns:") {
				dnsError = true
			}
		})

		if err != nil {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("\nUpgrade error: %v\n", err))
			runtime.EventsEmit(a.ctx, "upgrade:complete", map[string]interface{}{
				"success":  false,
				"dnsError": dnsError,
			})
			return
		}

		runtime.EventsEmit(a.ctx, "command:output", "\nUpgrade completed successfully.\n")
		runtime.EventsEmit(a.ctx, "upgrade:complete", map[string]interface{}{
			"success":  true,
			"dnsError": dnsError,
		})
	}()
}

type MaintenanceCommandInfo struct {
	ID               string `json:"id"`
	Label            string `json:"label"`
	Description      string `json:"description"`
	RequiresTerminal bool   `json:"requiresTerminal"`
	AllowStop        bool   `json:"allowStop"`
	Hook             string `json:"hook,omitempty"`
}

func (a *App) GetMaintenanceCommands(pkgName string) []MaintenanceCommandInfo {
	commands := a.metadata.GetMaintenanceCommands(pkgName)
	if commands == nil {
		return nil
	}

	result := make([]MaintenanceCommandInfo, len(commands))
	for i, cmd := range commands {
		result[i] = MaintenanceCommandInfo{
			ID:               cmd.ID,
			Label:            cmd.Label,
			Description:      cmd.Description,
			RequiresTerminal: cmd.RequiresTerminal,
			AllowStop:        cmd.AllowStop,
			Hook:             cmd.Hook,
		}
	}

	return result
}

type SystemTaskInfo struct {
	ID                 string `json:"id"`
	Label              string `json:"label"`
	Description        string `json:"description"`
	RequiresTerminal   bool   `json:"requiresTerminal"`
	NeedsWriteableRoot bool   `json:"needsWriteableRoot"`
}

func (a *App) GetSystemTasksInfo() []SystemTaskInfo {
	result := make([]SystemTaskInfo, len(device.SystemTasks))
	for i, task := range device.SystemTasks {
		result[i] = SystemTaskInfo{
			ID:                 task.ID,
			Label:              task.Label,
			Description:        task.Description,
			RequiresTerminal:   task.RequiresTerminal,
			NeedsWriteableRoot: task.NeedsWriteableRoot,
		}
	}
	return result
}

func (a *App) GetDeviceDisplayName(machine string) string {
	return device.GetDisplayName(machine)
}

func (a *App) GetDeviceArchitecture(deviceType string) string {
	return string(device.GetArchitecture(component.DeviceType(deviceType)))
}

type InstallProgress struct {
	Component string `json:"component"`
	Index     int    `json:"index"`
	Total     int    `json:"total"`
	Status    string `json:"status"`
	Message   string `json:"message"`
}

type InstallResult struct {
	Success  bool     `json:"success"`
	Errors   []string `json:"errors"`
	DNSError bool     `json:"dnsError"`
}

type FileInfo struct {
	Name    string `json:"name"`
	Path    string `json:"path"`
	Size    int64  `json:"size"`
	IsDir   bool   `json:"isDir"`
	ModTime int64  `json:"modTime"`
	Mode    string `json:"mode"`
}

type TransferProgress struct {
	Filename   string  `json:"filename"`
	BytesSent  int64   `json:"bytesSent"`
	TotalBytes int64   `json:"totalBytes"`
	Percentage float64 `json:"percentage"`
	Status     string  `json:"status"`
}

type FolderTransferProgress struct {
	CurrentFile    string  `json:"currentFile"`
	FilesDone      int     `json:"filesDone"`
	FilesTotal     int     `json:"filesTotal"`
	BytesDone      int64   `json:"bytesDone"`
	BytesTotal     int64   `json:"bytesTotal"`
	Percentage     float64 `json:"percentage"`
	Status         string  `json:"status"`
	ContainsFolder bool    `json:"containsFolder"`
}

type DialogActionRequest struct {
	Id    string `json:"id"`
	Label string `json:"label"`
	Type  string `json:"type"`
	Value string `json:"value"`
}

type DialogRequest struct {
	Title             string                `json:"title"`
	Message           string                `json:"message"`
	Note              string                `json:"note"`
	Steps             []string              `json:"steps"`
	ConfirmText       string                `json:"confirmText"`
	CancelText        string                `json:"cancelText"`
	InProgressMessage string                `json:"inProgressMessage"`
	InfoOnly          bool                  `json:"infoOnly"`
	InstallFlow       bool                  `json:"installFlow"`
	Actions           []DialogActionRequest `json:"actions"`
}

func dialogRequestFromConfig(cfg *component.DialogConfig) DialogRequest {
	var actions []DialogActionRequest
	for _, a := range cfg.Actions {
		actions = append(actions, DialogActionRequest{
			Id:    a.Id,
			Label: a.Label,
			Type:  a.Type,
			Value: a.Value,
		})
	}
	return DialogRequest{
		Title:             cfg.Title,
		Message:           cfg.Message,
		Note:              cfg.Note,
		Steps:             cfg.Steps,
		ConfirmText:       cfg.ConfirmText,
		CancelText:        cfg.CancelText,
		InProgressMessage: cfg.InProgressMessage,
		InfoOnly:          cfg.InfoOnly,
		InstallFlow:       cfg.InstallFlow,
		Actions:           actions,
	}
}

// InstallSimulationResult contains the result of simulating an install
type InstallSimulationResult struct {
	Packages  []string `json:"packages"`  // All packages that will be installed (including dependencies)
	Requested []string `json:"requested"` // Originally requested packages
}

// UninstallSimulationResult contains the result of simulating an uninstall
type UninstallSimulationResult struct {
	Packages          []string            `json:"packages"`          // Packages that will be removed
	Blocked           map[string][]string `json:"blocked"`           // Packages blocked by dependents
	RecursivePackages []string            `json:"recursivePackages"` // All packages if recursive removal is needed
	WorldDeps         []string            `json:"worldDeps"`         // World packages that must be removed
	AllAffected       []string            `json:"allAffected"`       // Complete list that will be purged
}

// SimulateInstall returns all packages that will be installed (including dependencies)
func (a *App) SimulateInstall(packageNames []string, deviceType string) (*InstallSimulationResult, error) {
	if a.vellumClient == nil {
		return &InstallSimulationResult{Packages: packageNames, Requested: packageNames}, nil
	}

	// Use SimulateAdd to get all packages that will be installed
	allPackages, err := a.vellumClient.SimulateAdd(packageNames...)
	if err != nil {
		debug.Printf("[DEBUG] SimulateAdd failed: %v, using packageNames only\n", err)
		return &InstallSimulationResult{Packages: packageNames, Requested: packageNames}, nil
	}

	// If nothing to install (all already installed), return empty
	if len(allPackages) == 0 {
		return &InstallSimulationResult{Packages: []string{}, Requested: packageNames}, nil
	}

	return &InstallSimulationResult{Packages: allPackages, Requested: packageNames}, nil
}

// SimulateUninstall returns simulation info for uninstalling packages
func (a *App) SimulateUninstall(packageNames []string) (*UninstallSimulationResult, error) {
	if a.vellumClient == nil {
		return &UninstallSimulationResult{Packages: packageNames}, nil
	}

	simResult, err := a.vellumClient.SimulateDel(packageNames...)
	if err != nil {
		debug.Printf("[DEBUG] SimulateDel failed: %v, trying recursive\n", err)
		recursiveList, rErr := a.vellumClient.SimulateDelRecursive(packageNames...)
		if rErr != nil {
			debug.Printf("[DEBUG] SimulateDelRecursive also failed: %v\n", rErr)
			return &UninstallSimulationResult{Packages: packageNames}, nil
		}
		return &UninstallSimulationResult{
			Packages:          packageNames,
			RecursivePackages: recursiveList,
		}, nil
	}

	packages := simResult.Packages
	if packages == nil {
		packages = []string{}
	}

	result := &UninstallSimulationResult{
		Packages: packages,
		Blocked:  simResult.Blocked,
	}

	// If there are blocked packages, also get the recursive list
	if len(simResult.Blocked) > 0 {
		recursiveList, err := a.vellumClient.SimulateDelRecursive(packageNames...)
		if err != nil {
			debug.Printf("[DEBUG] SimulateDelRecursive failed: %v\n", err)
		} else if len(recursiveList) > 0 {
			result.RecursivePackages = recursiveList
		}

		// If recursive simulation didn't return packages, build list from blocked info
		if len(result.RecursivePackages) == 0 {
			seen := make(map[string]bool)
			for _, name := range packageNames {
				seen[name] = true
			}
			for _, dependents := range simResult.Blocked {
				for _, dep := range dependents {
					seen[dep] = true
				}
			}
			all := make([]string, 0, len(seen))
			for name := range seen {
				all = append(all, name)
			}
			result.RecursivePackages = all
		}
	}

	// If nothing would be removed or packages are blocked, resolve world deps
	if a.vellumClient != nil && (len(result.Packages) == 0 || len(result.Blocked) > 0) {
		worldToRemove, allAffected, err := a.resolveWorldDeps(packageNames)
		if err != nil {
			debug.Printf("[DEBUG] resolveWorldDeps failed: %v\n", err)
		} else if len(worldToRemove) > 0 {
			result.WorldDeps = worldToRemove
			result.AllAffected = allAffected
		}
	}

	return result, nil
}

func (a *App) resolveWorldDeps(targets []string) (worldToRemove []string, allAffected []string, err error) {
	worldPkgs, err := a.vellumClient.GetWorldPackages()
	if err != nil {
		return nil, nil, fmt.Errorf("failed to read world file: %w", err)
	}

	worldSet := make(map[string]bool, len(worldPkgs))
	for _, pkg := range worldPkgs {
		worldSet[pkg] = true
	}

	visited := make(map[string]bool)
	queue := make([]string, len(targets))
	copy(queue, targets)
	for _, t := range targets {
		visited[t] = true
	}

	for len(queue) > 0 {
		pkg := queue[0]
		queue = queue[1:]

		rdeps, err := a.vellumClient.GetReverseDeps(pkg)
		if err != nil {
			debug.Printf("[DEBUG] GetReverseDeps(%s) failed: %v\n", pkg, err)
			continue
		}

		for _, rdep := range rdeps {
			if !visited[rdep] {
				visited[rdep] = true
				queue = append(queue, rdep)
			}
		}
	}

	for pkg := range visited {
		allAffected = append(allAffected, pkg)
		if worldSet[pkg] {
			worldToRemove = append(worldToRemove, pkg)
		}
	}

	if len(worldToRemove) == 0 {
		return nil, nil, nil
	}

	// Simulate deleting the world packages to get the full cascade list
	simResult, err := a.vellumClient.SimulateDel(worldToRemove...)
	if err != nil {
		debug.Printf("[DEBUG] SimulateDel for world deps failed: %v\n", err)
		return worldToRemove, allAffected, nil
	}

	for _, pkg := range simResult.Packages {
		if !visited[pkg] {
			visited[pkg] = true
			allAffected = append(allAffected, pkg)
		}
	}

	return worldToRemove, allAffected, nil
}

func (a *App) RespondToDialog(response string) {
	if a.dialogResponse != nil {
		a.dialogResponse <- response
	}
}

func (a *App) CancelInstallation() {
	a.mu.Lock()
	defer a.mu.Unlock()
	if a.installCancelCh != nil {
		close(a.installCancelCh)
		a.installCancelCh = nil
	}
}

func (a *App) InstallPackages(packageNames []string, deviceType string) {
	if a.logger != nil {
		a.logger.LogInstall("install", strings.Join(packageNames, ", "), "started")
	}
	go func() {
		a.mu.Lock()
		vc := a.vellumClient
		a.installCancelCh = make(chan struct{})
		cancelCh := a.installCancelCh
		a.mu.Unlock()
		if vc == nil {
			runtime.EventsEmit(a.ctx, "install:complete", InstallResult{
				Success: false,
				Errors:  []string{"Not connected"},
			})
			return
		}

		defer func() {
			a.mu.Lock()
			if a.installCancelCh == cancelCh {
				a.installCancelCh = nil
			}
			a.mu.Unlock()
		}()

		isCancelled := func() bool {
			select {
			case <-cancelCh:
				return true
			default:
				return false
			}
		}

		a.dialogResponse = make(chan string, 1)
		defer func() {
			close(a.dialogResponse)
			a.dialogResponse = nil
		}()

		arch := device.GetArchitecture(component.DeviceType(deviceType))

		ctx := component.CommandContext{
			Arch:   arch,
			Device: component.DeviceType(deviceType),
		}

		// Check proxy mode setting
		settings, _ := a.settingsStore.Load()
		proxyEnabled := settings == nil || settings.ProxyMode

		// Proxy download packages first
		a.mu.Lock()
		sshClient := a.client
		a.mu.Unlock()

		var allPackages []string
		if sshClient != nil && proxyEnabled {
			proxy := vellum.NewProxy(vc, sshClient, string(arch))
			runtime.EventsEmit(a.ctx, "install:progress", InstallProgress{
				Status:  "downloading",
				Message: "Downloading packages via reManager...",
			})

			var err error
			allPackages, err = proxy.ProxyDownloadWithProgress(packageNames, func(progress vellum.ProxyProgress) {
				runtime.EventsEmit(a.ctx, "install:progress", InstallProgress{
					Component: progress.Package,
					Index:     progress.Current - 1,
					Total:     progress.Total,
					Status:    progress.Phase,
					Message:   progress.Message,
				})
			})
			if err != nil {
				runtime.EventsEmit(a.ctx, "install:complete", InstallResult{
					Success: false,
					Errors:  []string{fmt.Sprintf("Proxy download failed: %v", err)},
				})
				return
			}
		} else {
			allPackages = packageNames
		}

		if isCancelled() {
			runtime.EventsEmit(a.ctx, "install:complete", InstallResult{
				Success: false,
				Errors:  []string{"Installation cancelled"},
			})
			return
		}

		exec := &wailsExecutor{app: a}
		inst := installer.NewInstaller(vc, a.metadata, exec)

		result := inst.Install(
			packageNames,
			allPackages,
			ctx,
			func(progress executor.ProgressInfo) {
				if a.logger != nil {
					a.logger.LogInstall("install", progress.CurrentComponent, progress.Message)
				}
				runtime.EventsEmit(a.ctx, "install:progress", InstallProgress{
					Component: progress.CurrentComponent,
					Index:     progress.CurrentIndex,
					Total:     progress.TotalComponents,
					Status:    string(progress.Status),
					Message:   progress.Message,
				})
			},
			func(hookResult *component.HookExecutionResult) error {
				if hookResult.DialogConfig != nil {
					runtime.EventsEmit(a.ctx, "hook:dialog", dialogRequestFromConfig(hookResult.DialogConfig))

					response := <-a.dialogResponse
					if response == "" || response == "cancel" {
						return fmt.Errorf("user cancelled")
					}

					runtime.EventsEmit(a.ctx, "hook:started", map[string]string{
						"title": hookResult.DialogConfig.Title,
					})

					if hookResult.Command != nil {
						runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", hookResult.Command.Script))
						if err := exec.Execute([]component.CommandResult{*hookResult.Command}); err != nil {
							return err
						}
					}

					if hookResult.DialogConfig.PostCommandDialog != nil {
						runtime.EventsEmit(a.ctx, "hook:dialog", dialogRequestFromConfig(hookResult.DialogConfig.PostCommandDialog))

						postResponse := <-a.dialogResponse
						for _, action := range hookResult.DialogConfig.PostCommandDialog.Actions {
							if action.Id == postResponse && action.Type == "run_command" {
								runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", action.Value))
								if err := exec.Execute([]component.CommandResult{{Script: action.Value}}); err != nil {
									return err
								}
								break
							}
						}
					}
				}
				return nil
			},
		)

		runtime.EventsEmit(a.ctx, "install:complete", InstallResult{
			Success:  result.Success,
			Errors:   result.Errors,
			DNSError: result.DNSError,
		})
	}()
}

func (a *App) UninstallPackages(packageNames []string, deviceType string) {
	if a.logger != nil {
		a.logger.LogInstall("uninstall", strings.Join(packageNames, ", "), "started")
	}
	go func() {
		a.mu.Lock()
		vc := a.vellumClient
		a.installCancelCh = make(chan struct{})
		cancelCh := a.installCancelCh
		a.mu.Unlock()
		if vc == nil {
			runtime.EventsEmit(a.ctx, "install:complete", InstallResult{
				Success: false,
				Errors:  []string{"Not connected"},
			})
			return
		}

		defer func() {
			a.mu.Lock()
			if a.installCancelCh == cancelCh {
				a.installCancelCh = nil
			}
			a.mu.Unlock()
		}()

		isCancelled := func() bool {
			select {
			case <-cancelCh:
				return true
			default:
				return false
			}
		}

		a.dialogResponse = make(chan string, 1)
		defer func() {
			close(a.dialogResponse)
			a.dialogResponse = nil
		}()

		arch := device.GetArchitecture(component.DeviceType(deviceType))

		ctx := component.CommandContext{
			Arch:   arch,
			Device: component.DeviceType(deviceType),
		}

		// Simulate uninstall to check for blockers and get full package list
		var allPackages []string
		useRecursive := false
		useBatch := false

		simResult, err := vc.SimulateDel(packageNames...)
		if err != nil {
			debug.Printf("[DEBUG] SimulateDel failed: %v, trying recursive\n", err)
			useRecursive = true
			allPackages, err = vc.SimulateDelRecursive(packageNames...)
			if err != nil {
				debug.Printf("[DEBUG] SimulateDelRecursive also failed: %v\n", err)
				allPackages = packageNames
			}
		} else if len(simResult.Blocked) > 0 || len(simResult.Packages) == 0 {
			worldToRemove, allAffected, wErr := a.resolveWorldDeps(packageNames)
			if wErr != nil || len(worldToRemove) == 0 {
				debug.Printf("[DEBUG] resolveWorldDeps failed or empty: %v\n", wErr)
				useRecursive = true
				allPackages, err = vc.SimulateDelRecursive(packageNames...)
				if err != nil {
					debug.Printf("[DEBUG] SimulateDelRecursive failed: %v\n", err)
					allPackages = packageNames
				}
			} else {
				packageNames = worldToRemove
				allPackages = allAffected
				useBatch = true
			}
		} else {
			allPackages = simResult.Packages
			if len(allPackages) == 0 {
				allPackages = packageNames
			}
		}

		if isCancelled() {
			runtime.EventsEmit(a.ctx, "install:complete", InstallResult{
				Success: false,
				Errors:  []string{"Uninstall cancelled"},
			})
			return
		}

		exec := &wailsExecutor{app: a}
		inst := installer.NewInstaller(vc, a.metadata, exec)

		result := inst.Uninstall(
			packageNames,
			allPackages,
			useRecursive,
			useBatch,
			ctx,
			func(progress executor.ProgressInfo) {
				runtime.EventsEmit(a.ctx, "install:progress", InstallProgress{
					Component: progress.CurrentComponent,
					Index:     progress.CurrentIndex,
					Total:     progress.TotalComponents,
					Status:    string(progress.Status),
					Message:   progress.Message,
				})
			},
			func(hookResult *component.HookExecutionResult) error {
				if hookResult.DialogConfig != nil {
					runtime.EventsEmit(a.ctx, "hook:dialog", dialogRequestFromConfig(hookResult.DialogConfig))

					response := <-a.dialogResponse
					if response == "" || response == "cancel" {
						return fmt.Errorf("user cancelled")
					}

					if hookResult.Command != nil {
						runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", hookResult.Command.Script))
						if err := exec.Execute([]component.CommandResult{*hookResult.Command}); err != nil {
							return err
						}
					}

					if hookResult.DialogConfig.PostCommandDialog != nil {
						runtime.EventsEmit(a.ctx, "hook:dialog", dialogRequestFromConfig(hookResult.DialogConfig.PostCommandDialog))

						postResponse := <-a.dialogResponse
						for _, action := range hookResult.DialogConfig.PostCommandDialog.Actions {
							if action.Id == postResponse && action.Type == "run_command" {
								runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", action.Value))
								if err := exec.Execute([]component.CommandResult{{Script: action.Value}}); err != nil {
									return err
								}
								break
							}
						}
					}
				}
				return nil
			},
		)

		runtime.EventsEmit(a.ctx, "install:complete", InstallResult{
			Success:  result.Success,
			Errors:   result.Errors,
			DNSError: result.DNSError,
		})
	}()
}

func (a *App) RunMaintenanceCommand(pkgName, commandID, deviceType string) {
	go func() {
		commands := a.metadata.GetMaintenanceCommands(pkgName)
		if commands == nil {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("No maintenance commands for package: %s\n", pkgName))
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		var cmd *vellum.MaintenanceCommand
		for i := range commands {
			if commands[i].ID == commandID {
				cmd = &commands[i]
				break
			}
		}
		if cmd == nil {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Command not found: %s\n", commandID))
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		if cmd.Hook != "" {
			hookFunc := vellum.GetHook(cmd.Hook)
			if hookFunc != nil {
				arch := device.GetArchitecture(component.DeviceType(deviceType))
				ctx := component.CommandContext{
					Arch:   arch,
					Device: component.DeviceType(deviceType),
				}

				hookResult, err := hookFunc(ctx)
				if err != nil {
					runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Hook error: %v\n", err))
					runtime.EventsEmit(a.ctx, "command:done", false)
					return
				}

				if hookResult != nil && hookResult.DialogConfig != nil {
					a.dialogResponse = make(chan string, 1)
					defer func() {
						close(a.dialogResponse)
						a.dialogResponse = nil
					}()

					runtime.EventsEmit(a.ctx, "hook:dialog", dialogRequestFromConfig(hookResult.DialogConfig))

					response := <-a.dialogResponse
					if response == "" || response == "cancel" {
						runtime.EventsEmit(a.ctx, "command:done", false)
						return
					}

					runtime.EventsEmit(a.ctx, "hook:started", map[string]string{
						"title": hookResult.DialogConfig.Title,
					})

					exec := &wailsExecutor{app: a}

					if hookResult.Command != nil {
						runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", hookResult.Command.Script))
						if err := exec.Execute([]component.CommandResult{*hookResult.Command}); err != nil {
							runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Error: %v\n", err))
							runtime.EventsEmit(a.ctx, "command:done", false)
							return
						}
					}

					if hookResult.DialogConfig.PostCommandDialog != nil {
						runtime.EventsEmit(a.ctx, "hook:dialog", dialogRequestFromConfig(hookResult.DialogConfig.PostCommandDialog))

						postResponse := <-a.dialogResponse
						for _, action := range hookResult.DialogConfig.PostCommandDialog.Actions {
							if action.Id == postResponse && action.Type == "run_command" {
								runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", action.Value))
								if err := exec.Execute([]component.CommandResult{{Script: action.Value}}); err != nil {
									runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Error: %v\n", err))
								}
								break
							}
						}
					}

					runtime.EventsEmit(a.ctx, "command:done", true)
					return
				}
			}
		}

		runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", cmd.Command))
		a.RunCommandWithOutput(cmd.Command, cmd.RequiresTerminal)
	}()
}

func (a *App) RunSystemTask(taskID, deviceType string) {
	go func() {
		task := device.GetSystemTask(taskID)
		if task == nil {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Task not found: %s\n", taskID))
			runtime.EventsEmit(a.ctx, "command:done", false)
			return
		}

		arch := device.GetArchitecture(component.DeviceType(deviceType))
		ctx := component.CommandContext{
			Arch:   arch,
			Device: component.DeviceType(deviceType),
		}

		cmdResults := task.Command(ctx)

		if task.NeedsWriteableRoot {
			cmdResults = commands.WrapWithWriteableRoot(cmdResults, component.DeviceType(deviceType))
			if err := a.acquireWriteableRoot(deviceType); err != nil {
				runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("Blocked: %v\n", err))
				runtime.EventsEmit(a.ctx, "command:done", false)
				return
			}
			defer a.releaseWriteableRoot(deviceType)
		}

		var operationErr error
		if a.logger != nil {
			a.operationLog = a.logger.StartCommandLog(a.connectedDeviceID, taskID)
			defer func() {
				a.operationLog.WriteExitCode(operationErr)
				a.operationLog.Close()
				a.operationLog = nil
			}()
		}

		for _, c := range cmdResults {
			runtime.EventsEmit(a.ctx, "command:output", fmt.Sprintf("$ %s\n", c.Script))

			done := make(chan bool, 1)
			unsub := runtime.EventsOn(a.ctx, "command:done", func(optionalData ...interface{}) {
				if len(optionalData) > 0 {
					if success, ok := optionalData[0].(bool); ok {
						done <- success
						return
					}
				}
				done <- false
			})

			a.RunCommandWithOutput(c.Script, c.RequiresPTY)
			success := <-done
			unsub()

			if !success {
				operationErr = fmt.Errorf("command failed: %s", c.Script)
				runtime.EventsEmit(a.ctx, "command:output", "Command failed, stopping execution\n")
				return
			}
		}
		runtime.EventsEmit(a.ctx, "systemtask:complete", true)
	}()
}

type wailsExecutor struct {
	app *App
}

func (e *wailsExecutor) Execute(cmds []component.CommandResult) error {
	var operationErr error
	if e.app.logger != nil && len(cmds) > 0 {
		name := cmds[0].Description
		if name == "" {
			name = "execute"
		}
		e.app.operationLog = e.app.logger.StartCommandLog(e.app.connectedDeviceID, name)
		defer func() {
			e.app.operationLog.WriteExitCode(operationErr)
			e.app.operationLog.Close()
			e.app.operationLog = nil
		}()
	}

	for _, cmd := range cmds {
		runtime.EventsEmit(e.app.ctx, "command:output", fmt.Sprintf("$ %s\n", cmd.Script))

		done := make(chan bool, 1)
		unsub := runtime.EventsOn(e.app.ctx, "command:done", func(optionalData ...interface{}) {
			if len(optionalData) > 0 {
				if success, ok := optionalData[0].(bool); ok {
					done <- success
					return
				}
			}
			done <- false
		})

		e.app.RunCommandWithOutput(cmd.Script, cmd.RequiresPTY)
		success := <-done
		unsub()

		if !success {
			operationErr = fmt.Errorf("command failed: %s", cmd.Description)
			return operationErr
		}
	}
	return nil
}

func (e *wailsExecutor) ExecuteWithOutput(cmd string) (string, error) {
	debug.Printf("[DEBUG] ExecuteWithOutput waiting for lock: %s\n", cmd[:min(50, len(cmd))])
	e.app.mu.Lock()
	debug.Printf("[DEBUG] ExecuteWithOutput got lock: %s\n", cmd[:min(50, len(cmd))])
	defer func() {
		e.app.mu.Unlock()
		debug.Printf("[DEBUG] ExecuteWithOutput released lock: %s\n", cmd[:min(50, len(cmd))])
	}()
	return e.app.runCommand(cmd)
}

func (e *wailsExecutor) ExecuteStreaming(cmd string, onOutput func(line string)) error {
	var cmdLog *logger.CommandLog
	if e.app.logger != nil {
		cmdLog = e.app.logger.StartCommandLog(e.app.connectedDeviceID, cmd)
	}
	defer cmdLog.Close()

	e.app.mu.Lock()
	if e.app.client == nil {
		e.app.mu.Unlock()
		return fmt.Errorf("not connected")
	}

	session, err := e.app.client.NewSession()
	if err != nil {
		e.app.mu.Unlock()
		return err
	}
	e.app.mu.Unlock()
	defer session.Close()

	stdout, err := session.StdoutPipe()
	if err != nil {
		return err
	}
	stderr, err := session.StderrPipe()
	if err != nil {
		return err
	}

	if err := session.Start(cmd); err != nil {
		return err
	}

	var wg sync.WaitGroup
	wg.Add(2)

	readLines := func(r io.Reader) {
		defer wg.Done()
		scanner := bufio.NewScanner(r)
		for scanner.Scan() {
			line := scanner.Text()
			cmdLog.Write(line + "\n")
			if onOutput != nil {
				onOutput(line)
			}
		}
	}

	go readLines(stdout)
	go readLines(stderr)

	err = session.Wait()
	wg.Wait()
	cmdLog.WriteExitCode(err)
	return err
}

func (a *App) GetAppVersion() string {
	return version
}

type UpdateCheckResult struct {
	UpdateAvailable bool   `json:"updateAvailable"`
	LatestVersion   string `json:"latestVersion"`
	CurrentVersion  string `json:"currentVersion"`
	ReleaseURL      string `json:"releaseURL"`
	Error           string `json:"error,omitempty"`
}

func (a *App) CheckForAppUpdate() UpdateCheckResult {
	result := UpdateCheckResult{
		CurrentVersion: version,
	}

	if version == "dev" {
		return result
	}

	if platform.IsRunningInFlatpak() {
		return a.checkFlatpakUpdate(result)
	}
	return a.checkGitHubUpdate(result)
}

func (a *App) checkFlatpakUpdate(result UpdateCheckResult) UpdateCheckResult {
	client := httputil.NewClient(10 * time.Second)
	resp, err := client.Get("https://flathub.org/api/v2/appstream/io.scottlabs.reManager")
	if err != nil {
		debug.Printf("[DEBUG] checkFlatpakUpdate: request failed: %v\n", err)
		result.Error = "network_error"
		return result
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		debug.Printf("[DEBUG] checkFlatpakUpdate: HTTP %d\n", resp.StatusCode)
		result.Error = "api_error"
		return result
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		result.Error = "read_error"
		return result
	}

	var appstream struct {
		Releases []struct {
			Version   string `json:"version"`
			Timestamp string `json:"timestamp"`
		} `json:"releases"`
	}

	if err := json.Unmarshal(body, &appstream); err != nil {
		result.Error = "parse_error"
		return result
	}

	if len(appstream.Releases) == 0 {
		result.Error = "no_releases"
		return result
	}

	latest := appstream.Releases[0].Version
	result.LatestVersion = latest
	result.ReleaseURL = "https://flathub.org/apps/io.scottlabs.reManager"
	result.UpdateAvailable = isNewerVersion(version, latest)

	debug.Printf("[DEBUG] checkFlatpakUpdate: current=%s, latest=%s, updateAvailable=%v\n",
		version, latest, result.UpdateAvailable)

	return result
}

func (a *App) checkGitHubUpdate(result UpdateCheckResult) UpdateCheckResult {
	client := httputil.NewClient(10 * time.Second)
	resp, err := client.Get("https://api.github.com/repos/rmitchellscott/remanager/releases/latest")
	if err != nil {
		debug.Printf("[DEBUG] checkGitHubUpdate: request failed: %v\n", err)
		result.Error = "network_error"
		return result
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		debug.Printf("[DEBUG] checkGitHubUpdate: HTTP %d\n", resp.StatusCode)
		result.Error = "api_error"
		return result
	}

	var release struct {
		TagName string `json:"tag_name"`
		HTMLURL string `json:"html_url"`
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		result.Error = "read_error"
		return result
	}

	if err := json.Unmarshal(body, &release); err != nil {
		result.Error = "parse_error"
		return result
	}

	result.LatestVersion = release.TagName
	result.ReleaseURL = release.HTMLURL
	result.UpdateAvailable = isNewerVersion(version, release.TagName)

	debug.Printf("[DEBUG] checkGitHubUpdate: current=%s, latest=%s, updateAvailable=%v\n",
		version, release.TagName, result.UpdateAvailable)

	return result
}

func isNewerVersion(current, latest string) bool {
	current = strings.TrimPrefix(current, "v")
	latest = strings.TrimPrefix(latest, "v")

	currentParts := strings.Split(current, ".")
	latestParts := strings.Split(latest, ".")

	for len(currentParts) < 3 {
		currentParts = append(currentParts, "0")
	}
	for len(latestParts) < 3 {
		latestParts = append(latestParts, "0")
	}

	for i := 0; i < 3; i++ {
		currNum, err1 := strconv.Atoi(currentParts[i])
		latestNum, err2 := strconv.Atoi(latestParts[i])

		if err1 != nil || err2 != nil {
			if latestParts[i] > currentParts[i] {
				return true
			}
			if latestParts[i] < currentParts[i] {
				return false
			}
			continue
		}

		if latestNum > currNum {
			return true
		}
		if latestNum < currNum {
			return false
		}
	}

	return false
}

type BehaviorSettings struct {
	ProxyMode                  bool `json:"proxyMode"`
	SuppressSystemFileWarnings bool `json:"suppressSystemFileWarnings"`
	PreventSleep               bool `json:"preventSleep"`
	CheckForUpdates            bool `json:"checkForUpdates"`
}

type SettingsInfo struct {
	BehaviorSettings
	TabVisibility      map[string]bool `json:"tabVisibility"`
	Theme              string          `json:"theme"`
	TerminalTheme      string          `json:"terminalTheme"`
	EditorTheme        string          `json:"editorTheme"`
	SSHAgentSocketPath string          `json:"sshAgentSocketPath"`
}

func (a *App) GetSettings() SettingsInfo {
	if a.settingsStore == nil {
		debug.Println("[DEBUG] GetSettings: settingsStore is nil")
		return SettingsInfo{
			BehaviorSettings: BehaviorSettings{
				ProxyMode:                  true,
				SuppressSystemFileWarnings: false,

				PreventSleep:               true,
				CheckForUpdates:            true,
			},
			TabVisibility: map[string]bool{"mods": true, "maintenance": true, "utilities": true},
			Theme:         "system",
			TerminalTheme: "match",
			EditorTheme:   "match",
		}
	}
	settings, err := a.settingsStore.Load()
	if err != nil {
		debug.Printf("[DEBUG] GetSettings: failed to load: %v\n", err)
		return SettingsInfo{
			BehaviorSettings: BehaviorSettings{
				ProxyMode:                  true,
				SuppressSystemFileWarnings: false,

				PreventSleep:               true,
				CheckForUpdates:            true,
			},
			TabVisibility: map[string]bool{"mods": true, "maintenance": true, "utilities": true},
			Theme:         "system",
			TerminalTheme: "match",
			EditorTheme:   "match",
		}
	}
	debug.Printf("[DEBUG] GetSettings: loaded PreventSleep=%v\n", settings.PreventSleep)
	return SettingsInfo{
		BehaviorSettings: BehaviorSettings{
			ProxyMode:                  settings.ProxyMode,
			SuppressSystemFileWarnings: settings.SuppressSystemFileWarnings,
			PreventSleep:               settings.PreventSleep,
			CheckForUpdates:            settings.CheckForUpdates,
		},
		TabVisibility:      settings.TabVisibility,
		Theme:              settings.Theme,
		TerminalTheme:      settings.TerminalTheme,
		EditorTheme:        settings.EditorTheme,
		SSHAgentSocketPath: settings.SSHAgentSocketPath,
	}
}

func (a *App) SaveSettings(tabVisibility map[string]bool, proxyMode bool, suppressSystemFileWarnings bool, preventSleep bool, theme string, terminalTheme string, editorTheme string, checkForUpdates bool, sshAgentSocketPath string) error {
	debug.Printf("[DEBUG] SaveSettings: preventSleep=%v, isConnected=%v\n", preventSleep, a.IsConnected())
	if a.settingsStore == nil {
		return fmt.Errorf("settings store not initialized")
	}
	settings := &storage.Settings{
		TabVisibility:              storage.TabVisibility(tabVisibility),
		ProxyMode:                  proxyMode,
		SuppressSystemFileWarnings: suppressSystemFileWarnings,
		PreventSleep:               preventSleep,
		Theme:                      theme,
		TerminalTheme:              terminalTheme,
		EditorTheme:                editorTheme,
		CheckForUpdates:            checkForUpdates,
		SSHAgentSocketPath:         sshAgentSocketPath,
	}

	if preventSleep && a.IsConnected() {
		debug.Println("[DEBUG] SaveSettings: starting prevent sleep")
		if err := a.StartPreventSleep(); err != nil {
			debug.Printf("[DEBUG] SaveSettings: StartPreventSleep failed: %v\n", err)
		}
	} else {
		debug.Println("[DEBUG] SaveSettings: stopping prevent sleep")
		a.StopPreventSleep()
	}

	return a.settingsStore.Save(settings)
}

func (a *App) GetSystemColorScheme() string {
	scheme, err := appearance.GetColorScheme()
	if err != nil {
		return "unknown"
	}
	switch scheme {
	case appearance.Dark:
		return "dark"
	case appearance.Light:
		return "light"
	default:
		return "unknown"
	}
}

func (a *App) UninstallVellum(removeAllPackages bool) {
	go func() {
		if a.vellumClient == nil {
			runtime.EventsEmit(a.ctx, "vellum:uninstall-error", "Not connected")
			return
		}

		runtime.EventsEmit(a.ctx, "vellum:uninstall-start")

		err := a.vellumClient.UninstallVellum(removeAllPackages, func(line string) {
			runtime.EventsEmit(a.ctx, "vellum:uninstall-output", line)
		})

		if err != nil {
			runtime.EventsEmit(a.ctx, "vellum:uninstall-error", err.Error())
			return
		}

		a.vellumClient = nil
		runtime.EventsEmit(a.ctx, "vellum:uninstall-complete")
	}()
}

func (a *App) CleanupBrokenVellum() {
	go func() {
		a.mu.Lock()
		client := a.client
		a.mu.Unlock()

		if client == nil {
			runtime.EventsEmit(a.ctx, "vellum:cleanup-error", "Not connected")
			return
		}

		runtime.EventsEmit(a.ctx, "vellum:cleanup-start")

		session, err := client.NewSession()
		if err != nil {
			runtime.EventsEmit(a.ctx, "vellum:cleanup-error", err.Error())
			return
		}

		err = session.Run("rm -rf " + vellum.VellumRoot)
		session.Close()

		if err != nil {
			runtime.EventsEmit(a.ctx, "vellum:cleanup-error", err.Error())
			return
		}

		a.vellumClient = nil
		runtime.EventsEmit(a.ctx, "vellum:cleanup-complete")
		runtime.EventsEmit(a.ctx, "vellum:bootstrap-prompt", nil)
	}()
}

// isSystemPath returns true if the path is outside /home/root (a system path)
func isSystemPath(path string) bool {
	cleanPath := filepath.Clean(path)
	return !strings.HasPrefix(cleanPath, "/home/root")
}

// makeFilesystemWritable makes the root filesystem writable on RMPP/RMPP-M devices
func (a *App) makeFilesystemWritable(client *ssh.Client) error {
	deviceType, err := a.detectDevice()
	if err != nil {
		return nil // If we can't detect, assume it's not RMPP
	}

	if deviceType != "rmpp" && deviceType != "rmppm" {
		return nil // Only RMPP devices have read-only root
	}

	session, err := client.NewSession()
	if err != nil {
		return fmt.Errorf("failed to create session: %w", err)
	}
	defer session.Close()

	// Remount root as rw and unmount /etc overlay
	cmd := `mount -o remount,rw / 2>/dev/null; if grep -q '^overlay.*/etc' /proc/mounts; then umount -l /etc 2>/dev/null; fi`
	if err := session.Run(cmd); err != nil {
		return fmt.Errorf("failed to make filesystem writable: %w", err)
	}

	return nil
}

// restoreFilesystem restores the /etc overlay and remounts root as read-only on RMPP/RMPP-M
func (a *App) restoreFilesystem(client *ssh.Client) error {
	deviceType, err := a.detectDevice()
	if err != nil {
		return nil
	}

	if deviceType != "rmpp" && deviceType != "rmppm" {
		return nil
	}

	// Step 1: Restore /etc overlay (if workdir exists)
	session1, err := client.NewSession()
	if err != nil {
		return fmt.Errorf("failed to create session: %w", err)
	}
	session1.Run(`if [ -d /var/volatile/.etc-work ]; then rm -rf /var/volatile/.etc-work/* 2>/dev/null; mount -t overlay overlay -o rw,relatime,lowerdir=/etc,upperdir=/var/volatile/etc,workdir=/var/volatile/.etc-work /etc 2>/dev/null; fi`)
	session1.Close()

	// Step 2: Sync and remount root as ro
	session2, err := client.NewSession()
	if err != nil {
		return fmt.Errorf("failed to create session: %w", err)
	}
	session2.Run("sync && mount -o remount,ro /")
	session2.Close()

	// Step 3: Verify root is actually read-only
	session3, err := client.NewSession()
	if err != nil {
		return fmt.Errorf("failed to create session: %w", err)
	}
	output, _ := session3.CombinedOutput(`grep ' / ' /proc/mounts | grep -q '\bro\b' && echo "ro" || echo "rw"`)
	session3.Close()

	if strings.TrimSpace(string(output)) != "ro" {
		return fmt.Errorf("failed to re-enable read-only root filesystem")
	}

	return nil
}

const (
	restoreMaxRetries = 3
	restoreRetryDelay = 1 * time.Second
)

// restoreFilesystemWithRetry attempts to restore the filesystem with automatic retries
func (a *App) restoreFilesystemWithRetry(client *ssh.Client) error {
	var lastErr error

	for attempt := 1; attempt <= restoreMaxRetries; attempt++ {
		lastErr = a.restoreFilesystem(client)
		if lastErr == nil {
			return nil
		}

		if attempt < restoreMaxRetries {
			time.Sleep(restoreRetryDelay)
		}
	}

	return lastErr
}

// restoreFilesystemDeferred wraps restore with retry logic and event emission for use in defer
func (a *App) restoreFilesystemDeferred(client *ssh.Client) {
	if err := a.restoreFilesystemWithRetry(client); err != nil {
		runtime.EventsEmit(a.ctx, "filesystem:restore-error", map[string]interface{}{
			"message": err.Error(),
		})
	}
}

// withWritableRoot wraps an operation that requires writable root, handling restore and error events
func (a *App) withWritableRoot(client *ssh.Client, path string, operation func() error) error {
	if !isSystemPath(path) {
		return operation()
	}

	if err := a.makeFilesystemWritable(client); err != nil {
		return err
	}

	opErr := operation()

	restoreErr := a.restoreFilesystemWithRetry(client)
	if restoreErr != nil {
		runtime.EventsEmit(a.ctx, "filesystem:restore-error", map[string]interface{}{
			"message":            restoreErr.Error(),
			"operationSucceeded": opErr == nil,
		})
	}

	return opErr
}

// RetryRestoreFilesystem attempts to restore the read-only filesystem state (called from frontend)
func (a *App) RetryRestoreFilesystem() error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	return a.restoreFilesystem(client)
}

// RebootDevice triggers a device reboot
func (a *App) RebootDevice() error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	session, err := client.NewSession()
	if err != nil {
		return fmt.Errorf("failed to create session: %w", err)
	}
	defer session.Close()

	session.Run("nohup sh -c 'sleep 1 && reboot' &>/dev/null &")
	return nil
}

func (a *App) getPartitionManager() (partition.Manager, error) {
	a.mu.Lock()
	client := a.client
	deviceType := a.connectedDeviceType
	a.mu.Unlock()

	if client == nil {
		return nil, fmt.Errorf("not connected")
	}

	exec := rmexecutor.NewSSH(client)
	fs, err := rmfilesystem.NewSSH(client)
	if err != nil {
		return nil, fmt.Errorf("failed to create filesystem client: %w", err)
	}

	return partition.NewManager(exec, fs, rmdevice.Type(deviceType)), nil
}

func (a *App) GetPartitionInfo() (*partition.SystemInfo, error) {
	mgr, err := a.getPartitionManager()
	if err != nil {
		return nil, err
	}
	return mgr.GetSystemInfo(context.Background())
}

func (a *App) SwitchBootPartition(partitionNumber int) (*partition.SwitchResult, error) {
	mgr, err := a.getPartitionManager()
	if err != nil {
		return nil, err
	}
	return mgr.SwitchBoot(context.Background(), partitionNumber)
}

func (a *App) GetAvailableOSVersions() ([]swupdate.OSVersionInfo, error) {
	a.mu.Lock()
	deviceType := a.connectedDeviceType
	a.mu.Unlock()

	if deviceType == "" {
		return nil, fmt.Errorf("not connected")
	}

	return swupdate.ListVersions(deviceType, nil)
}

func (a *App) CancelOSInstall() {
	a.mu.Lock()
	ch := a.osInstallCancelCh
	a.mu.Unlock()
	if ch != nil {
		close(ch)
	}
}

func (a *App) InstallOSVersion(version string) {
	go func() {
		a.mu.Lock()
		client := a.client
		deviceType := a.connectedDeviceType
		deviceID := a.connectedDeviceID
		cancelCh := make(chan struct{})
		a.osInstallCancelCh = cancelCh
		a.mu.Unlock()

		if client == nil {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "not connected"})
			return
		}

		versions, err := swupdate.ListVersions(deviceType, nil)
		if err != nil {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": err.Error()})
			return
		}

		var filename string
		for _, v := range versions {
			if v.Version == version {
				filename = v.Filename
				break
			}
		}
		if filename == "" {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "version not found"})
			return
		}

		url := "https://remarkable-software.s3.us-east-2.amazonaws.com/" + filename

		// Phase 1: Download to desktop
		runtime.EventsEmit(a.ctx, "software:install-progress", map[string]interface{}{"phase": "downloading", "percent": 0.0, "message": "Downloading..."})

		tmpFile, err := os.CreateTemp("", "remanager-swu-*.swu")
		if err != nil {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "failed to create temp file: " + err.Error()})
			return
		}
		tmpPath := tmpFile.Name()
		defer os.Remove(tmpPath)

		resp, err := http.Get(url)
		if err != nil {
			tmpFile.Close()
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "download failed: " + err.Error()})
			return
		}
		defer resp.Body.Close()

		if resp.StatusCode != 200 {
			tmpFile.Close()
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": fmt.Sprintf("download failed: HTTP %d", resp.StatusCode)})
			return
		}

		cancelled := func() bool {
			select {
			case <-cancelCh:
				return true
			default:
				return false
			}
		}

		totalSize := resp.ContentLength
		var downloaded int64
		buf := make([]byte, 32*1024)
		for {
			if cancelled() {
				tmpFile.Close()
				runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "cancelled"})
				return
			}
			n, readErr := resp.Body.Read(buf)
			if n > 0 {
				if _, writeErr := tmpFile.Write(buf[:n]); writeErr != nil {
					tmpFile.Close()
					runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "write error: " + writeErr.Error()})
					return
				}
				downloaded += int64(n)
				if totalSize > 0 {
					pct := float64(downloaded) / float64(totalSize) * 50.0
					runtime.EventsEmit(a.ctx, "software:install-progress", map[string]interface{}{"phase": "downloading", "percent": pct, "message": "Downloading..."})
				}
			}
			if readErr == io.EOF {
				break
			}
			if readErr != nil {
				tmpFile.Close()
				runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "download error: " + readErr.Error()})
				return
			}
		}
		tmpFile.Close()

		// Phase 2: Upload to device via SFTP
		runtime.EventsEmit(a.ctx, "software:install-progress", map[string]interface{}{"phase": "uploading", "percent": 50.0, "message": "Uploading to device..."})

		sftpClient, err := sftp.NewClient(client)
		if err != nil {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "SFTP error: " + err.Error()})
			return
		}
		defer sftpClient.Close()

		remotePath := "/tmp/" + filename
		localFile, err := os.Open(tmpPath)
		if err != nil {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "failed to open temp file: " + err.Error()})
			return
		}
		defer localFile.Close()

		remoteFile, err := sftpClient.Create(remotePath)
		if err != nil {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "failed to create remote file: " + err.Error()})
			return
		}

		stat, _ := localFile.Stat()
		uploadSize := stat.Size()
		var uploaded int64
		for {
			if cancelled() {
				remoteFile.Close()
				runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "cancelled"})
				return
			}
			n, readErr := localFile.Read(buf)
			if n > 0 {
				if _, writeErr := remoteFile.Write(buf[:n]); writeErr != nil {
					remoteFile.Close()
					runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "upload error: " + writeErr.Error()})
					return
				}
				uploaded += int64(n)
				if uploadSize > 0 {
					pct := 50.0 + float64(uploaded)/float64(uploadSize)*50.0
					runtime.EventsEmit(a.ctx, "software:install-progress", map[string]interface{}{"phase": "uploading", "percent": pct, "message": "Uploading to device..."})
				}
			}
			if readErr == io.EOF {
				break
			}
			if readErr != nil {
				remoteFile.Close()
				runtime.EventsEmit(a.ctx, "software:install-error", map[string]string{"error": "upload read error: " + readErr.Error()})
				return
			}
		}
		remoteFile.Close()

		// Phase 3: Install via swupdate-from-file
		runtime.EventsEmit(a.ctx, "software:install-progress", map[string]interface{}{"phase": "installing", "percent": 100.0, "message": "Installing..."})

		exec := rmexecutor.NewSSH(client)
		updater := rmupdate.NewManager(exec)

		var outputBuf bytes.Buffer
		var outputWriter io.Writer = &outputBuf
		var cmdLog *logger.CommandLog
		if a.logger != nil {
			cmdLog = a.logger.StartCommandLog(deviceID, "swupdate-install")
			defer func() {
				cmdLog.Close()
			}()
			outputWriter = io.MultiWriter(&outputBuf, &cmdLogWriter{cmdLog: cmdLog})
		}

		result, err := updater.Install(context.Background(), remotePath, outputWriter)
		if err != nil {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]interface{}{"error": "install failed: " + err.Error(), "output": outputBuf.String()})
			return
		}
		if !result.Success {
			runtime.EventsEmit(a.ctx, "software:install-error", map[string]interface{}{"error": "install failed: " + result.Message, "output": outputBuf.String()})
			return
		}

		// Phase 4: Finalize
		runtime.EventsEmit(a.ctx, "software:install-progress", map[string]interface{}{"phase": "finalizing", "percent": 100.0, "message": "Finalizing..."})

		session, err := client.NewSession()
		if err == nil {
			session.Run("rm -f " + remotePath)
			session.Close()
		}

		runtime.EventsEmit(a.ctx, "software:install-progress", map[string]interface{}{"phase": "complete", "percent": 100.0, "message": "Complete"})
		runtime.EventsEmit(a.ctx, "software:install-complete", map[string]interface{}{"version": version, "partition": "standby"})
	}()
}

type cmdLogWriter struct {
	cmdLog *logger.CommandLog
}

func (w *cmdLogWriter) Write(p []byte) (n int, err error) {
	w.cmdLog.Write(string(p))
	return len(p), nil
}

func (a *App) ListDirectory(dirPath string) ([]FileInfo, error) {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return nil, fmt.Errorf("not connected")
	}

	if dirPath == "" {
		dirPath = "/home/root"
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return nil, fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	entries, err := sftpClient.ReadDir(dirPath)
	if err != nil {
		return nil, fmt.Errorf("failed to read directory: %w", err)
	}

	var files []FileInfo
	for _, entry := range entries {
		fullPath := path.Join(dirPath, entry.Name())
		if dirPath == "/" {
			fullPath = "/" + entry.Name()
		}
		files = append(files, FileInfo{
			Name:    entry.Name(),
			Path:    fullPath,
			Size:    entry.Size(),
			IsDir:   entry.IsDir(),
			ModTime: entry.ModTime().Unix(),
			Mode:    entry.Mode().String(),
		})
	}

	sort.Slice(files, func(i, j int) bool {
		if files[i].IsDir != files[j].IsDir {
			return files[i].IsDir
		}
		return strings.ToLower(files[i].Name) < strings.ToLower(files[j].Name)
	})

	return files, nil
}

func (a *App) DownloadFile(remotePath string) {
	go func() {
		a.mu.Lock()
		client := a.client
		a.mu.Unlock()

		if client == nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]interface{}{
				"message": "Not connected.",
				"code":    apperrors.ErrHostDown,
			})
			return
		}

		filename := path.Base(remotePath)
		var lastDir string
		if a.settingsStore != nil {
			if settings, err := a.settingsStore.Load(); err == nil {
				lastDir = settings.LastDownloadDir
			}
		}
		localPath, err := saveFileDialog(a.ctx, "Save File", filename, lastDir)
		if err != nil || localPath == "" {
			return
		}
		if a.settingsStore != nil {
			if settings, err := a.settingsStore.Load(); err == nil {
				settings.LastDownloadDir = filepath.Dir(localPath)
				_ = a.settingsStore.Save(settings)
			}
		}

		sftpClient, err := sftp.NewClient(client)
		if err != nil {
			ue := apperrors.Classify(err)
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]interface{}{
				"message": ue.Message,
				"code":    ue.Code,
			})
			return
		}
		defer sftpClient.Close()

		remoteFile, err := sftpClient.Open(remotePath)
		if err != nil {
			ue := apperrors.Classify(err)
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]interface{}{
				"message": ue.Message,
				"code":    ue.Code,
			})
			return
		}
		defer remoteFile.Close()

		stat, err := remoteFile.Stat()
		if err != nil {
			ue := apperrors.Classify(err)
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]interface{}{
				"message": ue.Message,
				"code":    ue.Code,
			})
			return
		}
		totalBytes := stat.Size()

		localFile, err := os.Create(localPath)
		if err != nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": fmt.Sprintf("Failed to create local file: %v", err),
			})
			return
		}
		defer localFile.Close()

		buffer := make([]byte, 32*1024)
		var transferred int64

		for {
			n, err := remoteFile.Read(buffer)
			if n > 0 {
				_, writeErr := localFile.Write(buffer[:n])
				if writeErr != nil {
					runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
						"message": fmt.Sprintf("Failed to write to local file: %v", writeErr),
					})
					return
				}
				transferred += int64(n)

				var percentage float64
				if totalBytes > 0 {
					percentage = float64(transferred) / float64(totalBytes) * 100
				}
				runtime.EventsEmit(a.ctx, "filebrowser:progress", TransferProgress{
					Filename:   filename,
					BytesSent:  transferred,
					TotalBytes: totalBytes,
					Percentage: percentage,
					Status:     "downloading",
				})
			}
			if err == io.EOF {
				break
			}
			if err != nil {
				runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
					"message": fmt.Sprintf("Failed to read remote file: %v", err),
				})
				return
			}
		}

		runtime.EventsEmit(a.ctx, "filebrowser:progress", TransferProgress{
			Filename:   filename,
			BytesSent:  totalBytes,
			TotalBytes: totalBytes,
			Percentage: 100,
			Status:     "downloading",
		})

		runtime.EventsEmit(a.ctx, "filebrowser:download-complete", map[string]string{
			"path": remotePath,
		})
	}()
}

func (a *App) DownloadFolder(remotePath string) {
	go func() {
		a.mu.Lock()
		client := a.client
		a.mu.Unlock()

		if client == nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]interface{}{
				"message": "Not connected.",
				"code":    apperrors.ErrHostDown,
			})
			return
		}

		folderName := path.Base(remotePath)
		var lastDir string
		if a.settingsStore != nil {
			if settings, err := a.settingsStore.Load(); err == nil {
				lastDir = settings.LastDownloadDir
			}
		}
		localDir, err := openDirectoryDialog(a.ctx, "Save Folder To", lastDir)
		if err != nil || localDir == "" {
			return
		}
		if a.settingsStore != nil {
			if settings, err := a.settingsStore.Load(); err == nil {
				settings.LastDownloadDir = localDir
				_ = a.settingsStore.Save(settings)
			}
		}
		localBasePath := filepath.Join(localDir, folderName)

		a.folderTransferMu.Lock()
		a.folderTransferCancelCh = make(chan struct{})
		cancelCh := a.folderTransferCancelCh
		a.folderTransferMu.Unlock()

		sftpClient, err := sftp.NewClient(client)
		if err != nil {
			ue := apperrors.Classify(err)
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]interface{}{
				"message": ue.Message,
				"code":    ue.Code,
			})
			return
		}
		defer sftpClient.Close()

		filesTotal, bytesTotal, err := a.countRemoteFolder(sftpClient, remotePath)
		if err != nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": fmt.Sprintf("Failed to scan folder: %v", err),
			})
			return
		}

		var filesDone int
		var bytesDone int64
		var failedFiles []string

		err = a.downloadFolderRecursive(sftpClient, remotePath, localBasePath, &filesDone, &bytesDone, filesTotal, bytesTotal, &failedFiles, cancelCh)

		select {
		case <-cancelCh:
			runtime.EventsEmit(a.ctx, "filebrowser:folder-download-complete", map[string]interface{}{
				"cancelled": true,
			})
			return
		default:
		}

		if err != nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": fmt.Sprintf("Download failed: %v", err),
			})
			return
		}

		runtime.EventsEmit(a.ctx, "filebrowser:folder-download-complete", map[string]interface{}{
			"path":        remotePath,
			"failedFiles": failedFiles,
		})
	}()
}

func (a *App) countRemoteFolder(sftpClient *sftp.Client, remotePath string) (int, int64, error) {
	var filesTotal int
	var bytesTotal int64

	walker := sftpClient.Walk(remotePath)
	for walker.Step() {
		if err := walker.Err(); err != nil {
			continue
		}
		info := walker.Stat()
		if info.Mode()&os.ModeSymlink != 0 {
			filesTotal++
		} else if !info.IsDir() {
			filesTotal++
			bytesTotal += info.Size()
		}
	}

	return filesTotal, bytesTotal, nil
}

func (a *App) downloadFolderRecursive(sftpClient *sftp.Client, remotePath, localPath string, filesDone *int, bytesDone *int64, filesTotal int, bytesTotal int64, failedFiles *[]string, cancelCh chan struct{}) error {
	select {
	case <-cancelCh:
		return fmt.Errorf("cancelled")
	default:
	}

	info, err := sftpClient.Lstat(remotePath)
	if err != nil {
		return err
	}

	if info.Mode()&os.ModeSymlink != 0 {
		target, err := sftpClient.ReadLink(remotePath)
		if err != nil {
			*failedFiles = append(*failedFiles, remotePath)
			return nil
		}
		if err := os.Symlink(target, localPath); err != nil {
			*failedFiles = append(*failedFiles, remotePath)
		}
		*filesDone++
		a.emitFolderProgress(path.Base(remotePath), *filesDone, filesTotal, *bytesDone, bytesTotal, "downloading", true)
		return nil
	}

	if info.IsDir() {
		if err := os.MkdirAll(localPath, 0755); err != nil {
			return err
		}

		entries, err := sftpClient.ReadDir(remotePath)
		if err != nil {
			return err
		}

		for _, entry := range entries {
			remoteEntryPath := path.Join(remotePath, entry.Name())
			localEntryPath := filepath.Join(localPath, entry.Name())

			if err := a.downloadFolderRecursive(sftpClient, remoteEntryPath, localEntryPath, filesDone, bytesDone, filesTotal, bytesTotal, failedFiles, cancelCh); err != nil {
				return err
			}
		}
		return nil
	}

	remoteFile, err := sftpClient.Open(remotePath)
	if err != nil {
		*failedFiles = append(*failedFiles, remotePath)
		return nil
	}
	defer remoteFile.Close()

	localFile, err := os.Create(localPath)
	if err != nil {
		*failedFiles = append(*failedFiles, remotePath)
		return nil
	}
	defer localFile.Close()

	buffer := make([]byte, 32*1024)
	for {
		select {
		case <-cancelCh:
			return fmt.Errorf("cancelled")
		default:
		}

		n, err := remoteFile.Read(buffer)
		if n > 0 {
			if _, writeErr := localFile.Write(buffer[:n]); writeErr != nil {
				*failedFiles = append(*failedFiles, remotePath)
				return nil
			}
			*bytesDone += int64(n)
			a.emitFolderProgress(path.Base(remotePath), *filesDone, filesTotal, *bytesDone, bytesTotal, "downloading", true)
		}
		if err == io.EOF {
			break
		}
		if err != nil {
			*failedFiles = append(*failedFiles, remotePath)
			return nil
		}
	}

	*filesDone++
	a.emitFolderProgress(path.Base(remotePath), *filesDone, filesTotal, *bytesDone, bytesTotal, "downloading", true)
	return nil
}

func (a *App) emitFolderProgress(currentFile string, filesDone, filesTotal int, bytesDone, bytesTotal int64, status string, containsFolder bool) {
	var percentage float64
	if bytesTotal > 0 {
		percentage = float64(bytesDone) / float64(bytesTotal) * 100
	}
	runtime.EventsEmit(a.ctx, "filebrowser:folder-progress", FolderTransferProgress{
		CurrentFile:    currentFile,
		FilesDone:      filesDone,
		FilesTotal:     filesTotal,
		BytesDone:      bytesDone,
		BytesTotal:     bytesTotal,
		Percentage:     percentage,
		Status:         status,
		ContainsFolder: containsFolder,
	})
}

func (a *App) SelectFilesForUpload() []string {
	var lastDir string
	if a.settingsStore != nil {
		if settings, err := a.settingsStore.Load(); err == nil {
			lastDir = settings.LastUploadDir
		}
	}

	files, err := openMultipleFilesDialog(a.ctx, "Select files to upload", lastDir)
	if err != nil || len(files) == 0 {
		return []string{}
	}

	if a.settingsStore != nil {
		if settings, err := a.settingsStore.Load(); err == nil {
			settings.LastUploadDir = filepath.Dir(files[0])
			_ = a.settingsStore.Save(settings)
		}
	}

	return files
}

func (a *App) UploadFolder(remotePath string) {
	go func() {
		a.mu.Lock()
		client := a.client
		a.mu.Unlock()

		if client == nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": "Not connected",
			})
			return
		}

		localDir, err := openDirectoryDialog(a.ctx, "Select Folder to Upload", "")
		if err != nil || localDir == "" {
			return
		}

		a.folderTransferMu.Lock()
		a.folderTransferCancelCh = make(chan struct{})
		cancelCh := a.folderTransferCancelCh
		a.folderTransferMu.Unlock()

		folderName := filepath.Base(localDir)
		destPath := remotePath
		if strings.HasSuffix(remotePath, "/") || remotePath == "" {
			destPath = path.Join(remotePath, folderName)
		}

		needsWritable := isSystemPath(destPath)
		if needsWritable {
			if err := a.makeFilesystemWritable(client); err != nil {
				runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
					"message": fmt.Sprintf("Failed to prepare filesystem: %v", err),
				})
				return
			}
			defer a.restoreFilesystemDeferred(client)
		}

		sftpClient, err := sftp.NewClient(client)
		if err != nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": fmt.Sprintf("Failed to create SFTP client: %v", err),
			})
			return
		}
		defer sftpClient.Close()

		filesTotal, bytesTotal, err := a.countLocalFolder(localDir)
		if err != nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": fmt.Sprintf("Failed to scan folder: %v", err),
			})
			return
		}

		var filesDone int
		var bytesDone int64
		var failedFiles []string

		err = a.uploadFolderRecursive(sftpClient, localDir, destPath, &filesDone, &bytesDone, filesTotal, bytesTotal, &failedFiles, cancelCh)

		select {
		case <-cancelCh:
			runtime.EventsEmit(a.ctx, "filebrowser:folder-upload-complete", map[string]interface{}{
				"cancelled": true,
			})
			return
		default:
		}

		if err != nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": fmt.Sprintf("Upload failed: %v", err),
			})
			return
		}

		runtime.EventsEmit(a.ctx, "filebrowser:folder-upload-complete", map[string]interface{}{
			"path":        destPath,
			"failedFiles": failedFiles,
		})
	}()
}

func (a *App) countLocalFolder(localPath string) (int, int64, error) {
	var filesTotal int
	var bytesTotal int64

	err := filepath.WalkDir(localPath, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return nil
		}
		info, err := d.Info()
		if err != nil {
			return nil
		}
		if info.Mode()&os.ModeSymlink != 0 {
			filesTotal++
		} else if !d.IsDir() {
			filesTotal++
			bytesTotal += info.Size()
		}
		return nil
	})

	return filesTotal, bytesTotal, err
}

func (a *App) uploadFolderRecursive(sftpClient *sftp.Client, localPath, remotePath string, filesDone *int, bytesDone *int64, filesTotal int, bytesTotal int64, failedFiles *[]string, cancelCh chan struct{}) error {
	select {
	case <-cancelCh:
		return fmt.Errorf("cancelled")
	default:
	}

	info, err := os.Lstat(localPath)
	if err != nil {
		return err
	}

	if info.Mode()&os.ModeSymlink != 0 {
		target, err := os.Readlink(localPath)
		if err != nil {
			*failedFiles = append(*failedFiles, localPath)
			return nil
		}
		if err := sftpClient.Symlink(target, remotePath); err != nil {
			*failedFiles = append(*failedFiles, localPath)
		}
		*filesDone++
		a.emitFolderProgress(filepath.Base(localPath), *filesDone, filesTotal, *bytesDone, bytesTotal, "uploading", true)
		return nil
	}

	if info.IsDir() {
		if err := sftpClient.MkdirAll(remotePath); err != nil {
			return err
		}

		entries, err := os.ReadDir(localPath)
		if err != nil {
			return err
		}

		for _, entry := range entries {
			localEntryPath := filepath.Join(localPath, entry.Name())
			remoteEntryPath := path.Join(remotePath, entry.Name())

			if err := a.uploadFolderRecursive(sftpClient, localEntryPath, remoteEntryPath, filesDone, bytesDone, filesTotal, bytesTotal, failedFiles, cancelCh); err != nil {
				return err
			}
		}
		return nil
	}

	localFile, err := os.Open(localPath)
	if err != nil {
		*failedFiles = append(*failedFiles, localPath)
		return nil
	}
	defer localFile.Close()

	remoteFile, err := sftpClient.Create(remotePath)
	if err != nil {
		*failedFiles = append(*failedFiles, localPath)
		return nil
	}
	defer remoteFile.Close()

	buffer := make([]byte, 32*1024)
	for {
		select {
		case <-cancelCh:
			return fmt.Errorf("cancelled")
		default:
		}

		n, err := localFile.Read(buffer)
		if n > 0 {
			if _, writeErr := remoteFile.Write(buffer[:n]); writeErr != nil {
				*failedFiles = append(*failedFiles, localPath)
				return nil
			}
			*bytesDone += int64(n)
			a.emitFolderProgress(filepath.Base(localPath), *filesDone, filesTotal, *bytesDone, bytesTotal, "uploading", true)
		}
		if err == io.EOF {
			break
		}
		if err != nil {
			*failedFiles = append(*failedFiles, localPath)
			return nil
		}
	}

	*filesDone++
	a.emitFolderProgress(filepath.Base(localPath), *filesDone, filesTotal, *bytesDone, bytesTotal, "uploading", true)
	return nil
}

func (a *App) CancelFolderTransfer() {
	a.folderTransferMu.Lock()
	defer a.folderTransferMu.Unlock()
	if a.folderTransferCancelCh != nil {
		close(a.folderTransferCancelCh)
		a.folderTransferCancelCh = nil
	}
}

func (a *App) UploadFilesFromPaths(localPaths []string, remotePath string) {
	go func() {
		a.mu.Lock()
		client := a.client
		a.mu.Unlock()

		if client == nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": "Not connected",
			})
			return
		}

		if len(localPaths) == 0 {
			return
		}

		var hasFolder bool
		for _, localPath := range localPaths {
			info, err := os.Stat(localPath)
			if err == nil && info.IsDir() {
				hasFolder = true
				break
			}
		}

		if hasFolder || len(localPaths) > 1 {
			a.uploadMixedPaths(client, localPaths, remotePath, hasFolder)
			return
		}

		sftpClient, err := sftp.NewClient(client)
		if err != nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": fmt.Sprintf("Failed to create SFTP client: %v", err),
			})
			return
		}
		defer sftpClient.Close()

		for _, localPath := range localPaths {
			if err := a.uploadSingleFile(client, sftpClient, localPath, remotePath); err != nil {
				runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
					"message": err.Error(),
				})
			}
		}

		runtime.EventsEmit(a.ctx, "filebrowser:upload-complete", map[string]string{
			"path": remotePath,
		})
	}()
}

func (a *App) uploadMixedPaths(client *ssh.Client, localPaths []string, remotePath string, containsFolder bool) {
	a.folderTransferMu.Lock()
	a.folderTransferCancelCh = make(chan struct{})
	cancelCh := a.folderTransferCancelCh
	a.folderTransferMu.Unlock()

	needsWritable := isSystemPath(remotePath)
	if needsWritable {
		if err := a.makeFilesystemWritable(client); err != nil {
			runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
				"message": fmt.Sprintf("Failed to prepare filesystem: %v", err),
			})
			return
		}
		defer a.restoreFilesystemDeferred(client)
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		runtime.EventsEmit(a.ctx, "filebrowser:error", map[string]string{
			"message": fmt.Sprintf("Failed to create SFTP client: %v", err),
		})
		return
	}
	defer sftpClient.Close()

	var filesTotal int
	var bytesTotal int64
	for _, localPath := range localPaths {
		info, err := os.Stat(localPath)
		if err != nil {
			continue
		}
		if info.IsDir() {
			f, b, _ := a.countLocalFolder(localPath)
			filesTotal += f
			bytesTotal += b
		} else {
			filesTotal++
			bytesTotal += info.Size()
		}
	}

	var filesDone int
	var bytesDone int64
	var failedFiles []string

	for _, localPath := range localPaths {
		select {
		case <-cancelCh:
			runtime.EventsEmit(a.ctx, "filebrowser:folder-upload-complete", map[string]interface{}{
				"cancelled": true,
			})
			return
		default:
		}

		info, err := os.Stat(localPath)
		if err != nil {
			failedFiles = append(failedFiles, localPath)
			continue
		}

		if info.IsDir() {
			folderName := filepath.Base(localPath)
			destPath := path.Join(remotePath, folderName)
			if err := a.uploadFolderRecursive(sftpClient, localPath, destPath, &filesDone, &bytesDone, filesTotal, bytesTotal, &failedFiles, cancelCh); err != nil {
				continue
			}
		} else {
			destPath := path.Join(remotePath, info.Name())
			localFile, err := os.Open(localPath)
			if err != nil {
				failedFiles = append(failedFiles, localPath)
				continue
			}

			remoteFile, err := sftpClient.Create(destPath)
			if err != nil {
				localFile.Close()
				failedFiles = append(failedFiles, localPath)
				continue
			}

			buffer := make([]byte, 32*1024)
			for {
				n, err := localFile.Read(buffer)
				if n > 0 {
					if _, writeErr := remoteFile.Write(buffer[:n]); writeErr != nil {
						failedFiles = append(failedFiles, localPath)
						break
					}
					bytesDone += int64(n)
					a.emitFolderProgress(info.Name(), filesDone, filesTotal, bytesDone, bytesTotal, "uploading", containsFolder)
				}
				if err == io.EOF {
					filesDone++
					a.emitFolderProgress(info.Name(), filesDone, filesTotal, bytesDone, bytesTotal, "uploading", containsFolder)
					break
				}
				if err != nil {
					failedFiles = append(failedFiles, localPath)
					break
				}
			}
			localFile.Close()
			remoteFile.Close()
		}
	}

	runtime.EventsEmit(a.ctx, "filebrowser:folder-upload-complete", map[string]interface{}{
		"path":        remotePath,
		"failedFiles": failedFiles,
	})
}

func (a *App) uploadSingleFile(client *ssh.Client, sftpClient *sftp.Client, localPath string, remotePath string) error {
	localFile, err := os.Open(localPath)
	if err != nil {
		return fmt.Errorf("failed to open local file %s: %v", localPath, err)
	}
	defer localFile.Close()

	stat, err := localFile.Stat()
	if err != nil {
		return fmt.Errorf("failed to stat local file: %v", err)
	}

	if stat.IsDir() {
		return nil
	}

	totalBytes := stat.Size()
	filename := stat.Name()

	destPath := remotePath
	if strings.HasSuffix(remotePath, "/") || remotePath == "" {
		destPath = path.Join(remotePath, filename)
	}

	if isSystemPath(destPath) {
		if err := a.makeFilesystemWritable(client); err != nil {
			return fmt.Errorf("failed to prepare filesystem: %v", err)
		}
		defer a.restoreFilesystemDeferred(client)
	}

	remoteFile, err := sftpClient.Create(destPath)
	if err != nil {
		return fmt.Errorf("failed to create remote file: %v", err)
	}
	defer remoteFile.Close()

	buffer := make([]byte, 32*1024)
	var transferred int64

	for {
		n, err := localFile.Read(buffer)
		if n > 0 {
			_, writeErr := remoteFile.Write(buffer[:n])
			if writeErr != nil {
				return fmt.Errorf("failed to write to remote file: %v", writeErr)
			}
			transferred += int64(n)

			var percentage float64
			if totalBytes > 0 {
				percentage = float64(transferred) / float64(totalBytes) * 100
			}
			runtime.EventsEmit(a.ctx, "filebrowser:progress", TransferProgress{
				Filename:   filename,
				BytesSent:  transferred,
				TotalBytes: totalBytes,
				Percentage: percentage,
				Status:     "uploading",
			})
		}
		if err == io.EOF {
			break
		}
		if err != nil {
			return fmt.Errorf("failed to read local file: %v", err)
		}
	}

	runtime.EventsEmit(a.ctx, "filebrowser:progress", TransferProgress{
		Filename:   filename,
		BytesSent:  totalBytes,
		TotalBytes: totalBytes,
		Percentage: 100,
		Status:     "uploading",
	})

	return nil
}

func (a *App) DeletePath(path string) error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	// Make filesystem writable for system paths on RMPP devices
	if isSystemPath(path) {
		if err := a.makeFilesystemWritable(client); err != nil {
			return err
		}
		defer a.restoreFilesystemDeferred(client)
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	stat, err := sftpClient.Stat(path)
	if err != nil {
		return fmt.Errorf("failed to stat path: %w", err)
	}

	if stat.IsDir() {
		entries, err := sftpClient.ReadDir(path)
		if err != nil {
			return fmt.Errorf("failed to read directory: %w", err)
		}
		if len(entries) > 0 {
			session, err := client.NewSession()
			if err != nil {
				return fmt.Errorf("failed to create SSH session: %w", err)
			}
			defer session.Close()
			_, err = session.CombinedOutput(fmt.Sprintf("rm -rf %q", path))
			if err != nil {
				return fmt.Errorf("failed to delete directory: %w", err)
			}
		} else {
			err = sftpClient.RemoveDirectory(path)
			if err != nil {
				return fmt.Errorf("failed to remove directory: %w", err)
			}
		}
	} else {
		err = sftpClient.Remove(path)
		if err != nil {
			return fmt.Errorf("failed to delete file: %w", err)
		}
	}

	return nil
}

func (a *App) RenamePath(oldPath, newPath string) error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	// Make filesystem writable for system paths on RMPP devices
	if isSystemPath(oldPath) || isSystemPath(newPath) {
		if err := a.makeFilesystemWritable(client); err != nil {
			return err
		}
		defer a.restoreFilesystemDeferred(client)
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	err = sftpClient.Rename(oldPath, newPath)
	if err != nil {
		return fmt.Errorf("failed to rename: %w", err)
	}

	return nil
}

func (a *App) CreateDirectory(path string) error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	// Make filesystem writable for system paths on RMPP devices
	if isSystemPath(path) {
		if err := a.makeFilesystemWritable(client); err != nil {
			return err
		}
		defer a.restoreFilesystemDeferred(client)
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	err = sftpClient.Mkdir(path)
	if err != nil {
		return fmt.Errorf("failed to create directory: %w", err)
	}

	return nil
}

type BackupInfo struct {
	Name      string `json:"name"`
	Timestamp int64  `json:"timestamp"`
	Size      int64  `json:"size"`
}

func (a *App) ReadConfigFile() (string, error) {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return "", fmt.Errorf("not connected")
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return "", fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	file, err := sftpClient.Open("/home/root/.config/remarkable/xochitl.conf")
	if err != nil {
		return "", fmt.Errorf("failed to open config file: %w", err)
	}
	defer file.Close()

	content, err := io.ReadAll(file)
	if err != nil {
		return "", fmt.Errorf("failed to read config file: %w", err)
	}

	return string(content), nil
}

func (a *App) WriteConfigFile(content string) error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	_, err := ini.Load([]byte(content))
	if err != nil {
		return fmt.Errorf("invalid INI syntax: %w", err)
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	tmpPath := "/home/root/.config/remarkable/xochitl.conf.tmp"
	finalPath := "/home/root/.config/remarkable/xochitl.conf"

	tmpFile, err := sftpClient.Create(tmpPath)
	if err != nil {
		return fmt.Errorf("failed to create temp file: %w", err)
	}

	_, err = tmpFile.Write([]byte(content))
	if err != nil {
		tmpFile.Close()
		sftpClient.Remove(tmpPath)
		return fmt.Errorf("failed to write to temp file: %w", err)
	}
	tmpFile.Close()

	// Delete the target file first - Rename only works when destination doesn't exist
	_ = sftpClient.Remove(finalPath)

	err = sftpClient.Rename(tmpPath, finalPath)
	if err != nil {
		sftpClient.Remove(tmpPath)
		return fmt.Errorf("failed to rename temp file: %w", err)
	}

	return nil
}

func (a *App) BackupConfigFile() (string, error) {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return "", fmt.Errorf("not connected")
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return "", fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	configPath := "/home/root/.config/remarkable/xochitl.conf"
	file, err := sftpClient.Open(configPath)
	if err != nil {
		return "", fmt.Errorf("failed to open config file: %w", err)
	}
	defer file.Close()

	content, err := io.ReadAll(file)
	if err != nil {
		return "", fmt.Errorf("failed to read config file: %w", err)
	}

	backupName := fmt.Sprintf("xochitl.conf.backup-%s", time.Now().Format("2006-01-02-150405"))
	backupPath := path.Join("/home/root/.config/remarkable", backupName)

	backupFile, err := sftpClient.Create(backupPath)
	if err != nil {
		return "", fmt.Errorf("failed to create backup file: %w", err)
	}
	defer backupFile.Close()

	_, err = backupFile.Write(content)
	if err != nil {
		return "", fmt.Errorf("failed to write backup file: %w", err)
	}

	return backupName, nil
}

func (a *App) ListConfigBackups() ([]BackupInfo, error) {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return nil, fmt.Errorf("not connected")
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return nil, fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	entries, err := sftpClient.ReadDir("/home/root/.config/remarkable")
	if err != nil {
		return nil, fmt.Errorf("failed to read directory: %w", err)
	}

	var backups []BackupInfo
	for _, entry := range entries {
		if strings.HasPrefix(entry.Name(), "xochitl.conf.backup-") {
			backups = append(backups, BackupInfo{
				Name:      entry.Name(),
				Timestamp: entry.ModTime().Unix(),
				Size:      entry.Size(),
			})
		}
	}

	sort.Slice(backups, func(i, j int) bool {
		return backups[i].Timestamp > backups[j].Timestamp
	})

	return backups, nil
}

func (a *App) RestoreConfigBackup(backupName string) error {
	debug.Println("RestoreConfigBackup called with backupName:", backupName)
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		debug.Println("RestoreConfigBackup: not connected")
		return fmt.Errorf("not connected")
	}

	if !strings.HasPrefix(backupName, "xochitl.conf.backup-") {
		debug.Println("RestoreConfigBackup: invalid backup name")
		return fmt.Errorf("invalid backup name")
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		debug.Println("RestoreConfigBackup: failed to create SFTP client:", err)
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	backupPath := path.Join("/home/root/.config/remarkable", backupName)
	debug.Println("RestoreConfigBackup: opening backup file:", backupPath)
	file, err := sftpClient.Open(backupPath)
	if err != nil {
		debug.Println("RestoreConfigBackup: failed to open backup file:", err)
		return fmt.Errorf("failed to open backup file: %w", err)
	}
	defer file.Close()

	content, err := io.ReadAll(file)
	if err != nil {
		debug.Println("RestoreConfigBackup: failed to read backup file:", err)
		return fmt.Errorf("failed to read backup file: %w", err)
	}
	debug.Println("RestoreConfigBackup: read", len(content), "bytes from backup")

	_, err = ini.Load(content)
	if err != nil {
		debug.Println("RestoreConfigBackup: backup file has invalid INI syntax:", err)
		return fmt.Errorf("backup file has invalid INI syntax: %w", err)
	}

	debug.Println("RestoreConfigBackup: calling WriteConfigFile")
	err = a.WriteConfigFile(string(content))
	if err != nil {
		debug.Println("RestoreConfigBackup: WriteConfigFile failed:", err)
	} else {
		debug.Println("RestoreConfigBackup: success")
	}
	return err
}

func (a *App) SelectBackupFile() string {
	a.mu.Lock()
	deviceID := a.connectedDeviceID
	a.mu.Unlock()

	rawDeviceName := ""
	if savedDevice, err := a.deviceStore.Get(deviceID); err == nil && savedDevice.Name != "" {
		rawDeviceName = savedDevice.Name
	}
	deviceName := "device"
	if rawDeviceName != "" {
		deviceName = sanitizeFilename(rawDeviceName)
	}

	timestamp := time.Now().Format("2006-01-02-150405")
	defaultName := fmt.Sprintf("remarkable-backup-%s-%s.tar.zst", deviceName, timestamp)
	destPath, err := saveFileDialog(a.ctx, "Save Backup", defaultName, "")
	if err != nil || destPath == "" {
		return ""
	}
	return destPath
}

func (a *App) CreateDeviceBackup(destPath string) {
	go func() {
		a.mu.Lock()
		client := a.client
		deviceID := a.connectedDeviceID
		a.mu.Unlock()

		if client == nil {
			runtime.EventsEmit(a.ctx, "backup:error", map[string]string{
				"message": "Not connected to device",
			})
			return
		}

		rawDeviceName := ""
		if savedDevice, err := a.deviceStore.Get(deviceID); err == nil && savedDevice.Name != "" {
			rawDeviceName = savedDevice.Name
		}

		sftpClient, err := sftp.NewClient(client)
		if err != nil {
			runtime.EventsEmit(a.ctx, "backup:error", map[string]string{
				"message": fmt.Sprintf("Failed to create SFTP client: %v", err),
			})
			return
		}
		defer sftpClient.Close()

		a.backupMu.Lock()
		a.backupCancelCh = make(chan struct{})
		cancelCh := a.backupCancelCh
		a.backupMu.Unlock()

		manager := backup.Manager{
			Ctx:        a.ctx,
			SftpClient: sftpClient,
			SSHClient:  client,
			CancelCh:   cancelCh,
			ProgressFn: func(p backup.Progress) {
				runtime.EventsEmit(a.ctx, "backup:progress", p)
			},
			DeviceName: rawDeviceName,
			DeviceID:   deviceID,
		}

		sources := []string{
			"/home/root/.local/share/remarkable/xochitl",
			"/home/root/.config/remarkable",
		}

		err = manager.CreateBackup(destPath, sources)

		a.backupMu.Lock()
		a.backupCancelCh = nil
		a.backupMu.Unlock()

		if err != nil {
			runtime.EventsEmit(a.ctx, "backup:error", map[string]string{
				"message": err.Error(),
			})
		} else {
			runtime.EventsEmit(a.ctx, "backup:complete", map[string]string{
				"message": "Backup completed successfully",
				"path":    destPath,
			})
		}
	}()
}

func (a *App) SelectRestoreFile() string {
	archivePath, err := openFileDialog(a.ctx, "Select Backup to Restore", "")
	if err != nil || archivePath == "" {
		return ""
	}

	metadata, err := backup.ReadBackupMetadata(archivePath)
	if err == nil && metadata != nil && metadata.DeviceID != "" {
		a.mu.Lock()
		currentDeviceID := a.connectedDeviceID
		a.mu.Unlock()

		if currentDeviceID != "" && metadata.DeviceID != currentDeviceID {
			currentDeviceName := ""
			if savedDevice, err := a.deviceStore.Get(currentDeviceID); err == nil {
				currentDeviceName = savedDevice.Name
			}
			runtime.EventsEmit(a.ctx, "restore:device-mismatch", map[string]string{
				"backupDevice":  metadata.DeviceName,
				"currentDevice": currentDeviceName,
			})
		}
	}

	return archivePath
}

func (a *App) RestoreDeviceBackup(archivePath string) {
	go func() {
		a.mu.Lock()
		client := a.client
		a.mu.Unlock()

		if client == nil {
			runtime.EventsEmit(a.ctx, "restore:error", map[string]string{
				"message": "Not connected to device",
			})
			return
		}

		sftpClient, err := sftp.NewClient(client)
		if err != nil {
			runtime.EventsEmit(a.ctx, "restore:error", map[string]string{
				"message": fmt.Sprintf("Failed to create SFTP client: %v", err),
			})
			return
		}
		defer sftpClient.Close()

		a.backupMu.Lock()
		a.backupCancelCh = make(chan struct{})
		cancelCh := a.backupCancelCh
		a.backupMu.Unlock()

		manager := backup.Manager{
			Ctx:        a.ctx,
			SftpClient: sftpClient,
			SSHClient:  client,
			CancelCh:   cancelCh,
			ProgressFn: func(p backup.Progress) {
				runtime.EventsEmit(a.ctx, "restore:progress", p)
			},
		}

		err = manager.RestoreBackup(archivePath)

		a.backupMu.Lock()
		a.backupCancelCh = nil
		a.backupMu.Unlock()

		if err != nil {
			runtime.EventsEmit(a.ctx, "restore:error", map[string]string{
				"message": err.Error(),
			})
		} else {
			runtime.EventsEmit(a.ctx, "restore:complete", map[string]string{
				"message": "Restore completed successfully! Please reboot your device for changes to take effect.",
			})
		}
	}()
}

func (a *App) CancelBackup() {
	a.backupMu.Lock()
	defer a.backupMu.Unlock()

	if a.backupCancelCh != nil {
		close(a.backupCancelCh)
		a.backupCancelCh = nil
	}
}

func (a *App) RevealInFileManager(path string) {
	dir := filepath.Dir(path)

	if platform.IsRunningInFlatpak() {
		file, err := os.Open(dir)
		if err != nil {
			open.Start(dir)
			return
		}
		defer file.Close()

		if err := openuri.OpenDirectory("", file.Fd(), nil); err != nil {
			open.Start(dir)
		}
		return
	}

	open.Start(dir)
}

func (a *App) IsSleepScreenSupported() bool {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return false
	}

	output, err := a.runCommand("grep REMARKABLE_RELEASE_VERSION /usr/share/remarkable/update.conf")
	if err != nil {
		output, err = a.runCommand("grep IMG_VERSION /etc/os-release")
		if err != nil {
			return false
		}
	}

	parts := strings.SplitN(output, "=", 2)
	if len(parts) != 2 {
		return false
	}
	version := strings.Trim(strings.TrimSpace(parts[1]), "\"")

	versionParts := strings.Split(version, ".")
	if len(versionParts) < 2 {
		return false
	}

	major, err := strconv.Atoi(versionParts[0])
	if err != nil {
		return false
	}
	minor, err := strconv.Atoi(versionParts[1])
	if err != nil {
		return false
	}

	// Supported: 3.2-3.13 or 3.20+
	if major == 3 {
		return (minor >= 2 && minor <= 13) || minor >= 20
	}
	return major > 3
}

func (a *App) GetSleepScreen() (string, error) {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return "", fmt.Errorf("not connected")
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return "", fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	configPath := "/home/root/.config/remarkable/xochitl.conf"

	file, err := sftpClient.Open(configPath)
	if err != nil {
		return "", fmt.Errorf("failed to open config file: %w", err)
	}
	content, err := io.ReadAll(file)
	file.Close()
	if err != nil {
		return "", fmt.Errorf("failed to read config file: %w", err)
	}

	cfg, err := ini.Load(content)
	if err != nil {
		return "", fmt.Errorf("invalid config file syntax: %w", err)
	}

	section := cfg.Section("General")
	if !section.HasKey("SleepScreenPath") {
		return "", nil
	}
	return section.Key("SleepScreenPath").String(), nil
}

func (a *App) ResetSleepScreen() error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	configPath := "/home/root/.config/remarkable/xochitl.conf"

	file, err := sftpClient.Open(configPath)
	if err != nil {
		return fmt.Errorf("failed to open config file: %w", err)
	}
	content, err := io.ReadAll(file)
	file.Close()
	if err != nil {
		return fmt.Errorf("failed to read config file: %w", err)
	}

	cfg, err := ini.Load(content)
	if err != nil {
		return fmt.Errorf("invalid config file syntax: %w", err)
	}

	section := cfg.Section("General")
	section.DeleteKey("SleepScreenPath")

	var buf bytes.Buffer
	_, err = cfg.WriteTo(&buf)
	if err != nil {
		return fmt.Errorf("failed to serialize config: %w", err)
	}

	tmpPath := configPath + ".tmp"
	tmpFile, err := sftpClient.Create(tmpPath)
	if err != nil {
		return fmt.Errorf("failed to create temp file: %w", err)
	}

	_, err = tmpFile.Write(buf.Bytes())
	if err != nil {
		tmpFile.Close()
		sftpClient.Remove(tmpPath)
		return fmt.Errorf("failed to write to temp file: %w", err)
	}
	tmpFile.Close()

	_ = sftpClient.Remove(configPath)
	err = sftpClient.Rename(tmpPath, configPath)
	if err != nil {
		sftpClient.Remove(tmpPath)
		return fmt.Errorf("failed to rename temp file: %w", err)
	}

	return nil
}

func (a *App) SetSleepScreen(imagePath string) error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	configPath := "/home/root/.config/remarkable/xochitl.conf"

	file, err := sftpClient.Open(configPath)
	if err != nil {
		return fmt.Errorf("failed to open config file: %w", err)
	}
	content, err := io.ReadAll(file)
	file.Close()
	if err != nil {
		return fmt.Errorf("failed to read config file: %w", err)
	}

	cfg, err := ini.Load(content)
	if err != nil {
		return fmt.Errorf("invalid config file syntax: %w", err)
	}

	section := cfg.Section("General")
	section.Key("SleepScreenPath").SetValue(imagePath)

	var buf bytes.Buffer
	_, err = cfg.WriteTo(&buf)
	if err != nil {
		return fmt.Errorf("failed to serialize config: %w", err)
	}

	tmpPath := configPath + ".tmp"
	tmpFile, err := sftpClient.Create(tmpPath)
	if err != nil {
		return fmt.Errorf("failed to create temp file: %w", err)
	}

	_, err = tmpFile.Write(buf.Bytes())
	if err != nil {
		tmpFile.Close()
		sftpClient.Remove(tmpPath)
		return fmt.Errorf("failed to write to temp file: %w", err)
	}
	tmpFile.Close()

	_ = sftpClient.Remove(configPath)
	err = sftpClient.Rename(tmpPath, configPath)
	if err != nil {
		sftpClient.Remove(tmpPath)
		return fmt.Errorf("failed to rename temp file: %w", err)
	}

	return nil
}

func (a *App) RestartXochitl() error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	session, err := client.NewSession()
	if err != nil {
		return fmt.Errorf("failed to create session: %w", err)
	}
	defer session.Close()

	_, err = session.CombinedOutput("systemctl restart xochitl")
	if err != nil {
		return fmt.Errorf("failed to restart xochitl: %w", err)
	}

	return nil
}


func (a *App) RescanLibrary() error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	session, err := client.NewSession()
	if err != nil {
		return fmt.Errorf("failed to create session: %w", err)
	}
	defer session.Close()

	out, err := session.CombinedOutput("echo '>erescanLibrary:' > /run/xovi-mb; cat /run/xovi-mb-out")
	if err != nil {
		return fmt.Errorf("failed to rescan library: %w", err)
	}

	resp := strings.TrimSpace(string(out))
	if strings.HasPrefix(resp, "ERROR:") {
		return fmt.Errorf("rescan library: %s", resp)
	}

	return nil
}

// SelectPDFFile opens a native file dialog filtered to PDF files and returns
// the chosen path, or an empty string if the user cancelled.
func (a *App) SelectPDFFile() string {
	if platform.IsRunningInFlatpak() {
		home, _ := os.UserHomeDir()
		files, err := filechooser.OpenFile("", "Select PDF", &filechooser.OpenFileOptions{
			CurrentFolder: home,
		})
		if err != nil || len(files) == 0 {
			return ""
		}
		return strings.TrimPrefix(files[0], "file://")
	}
	home, _ := os.UserHomeDir()
	p, err := runtime.OpenFileDialog(a.ctx, runtime.OpenDialogOptions{
		Title:            "Select PDF",
		DefaultDirectory: home,
		Filters: []runtime.FileFilter{
			{DisplayName: "PDF files", Pattern: "*.pdf"},
		},
	})
	if err != nil {
		return ""
	}
	return p
}

type PDFFileInfo struct {
	Path      string `json:"path"`
	Size      int64  `json:"size"`
	PageCount int    `json:"pageCount"`
}

func (a *App) SelectPDFFiles() []string {
	return a.SelectImportFiles()
}

func (a *App) SelectImportFiles() []string {
	if platform.IsRunningInFlatpak() {
		home, _ := os.UserHomeDir()
		files, err := filechooser.OpenFile("", "Select documents", &filechooser.OpenFileOptions{
			CurrentFolder: home,
			Multiple:      true,
			Filters: []*filechooser.Filter{
				{Name: "Documents", Rules: []filechooser.Rule{
					{Type: filechooser.GlobPattern, Pattern: "*.pdf"},
					{Type: filechooser.GlobPattern, Pattern: "*.epub"},
					{Type: filechooser.GlobPattern, Pattern: "*.rmdoc"},
				}},
			},
		})
		if err != nil || len(files) == 0 {
			return []string{}
		}
		for i, f := range files {
			files[i] = strings.TrimPrefix(f, "file://")
		}
		return files
	}
	home, _ := os.UserHomeDir()
	files, err := runtime.OpenMultipleFilesDialog(a.ctx, runtime.OpenDialogOptions{
		Title:            "Select documents",
		DefaultDirectory: home,
		Filters: []runtime.FileFilter{
			{DisplayName: "Documents (PDF, ePub, rmdoc)", Pattern: "*.pdf;*.epub;*.rmdoc"},
		},
	})
	if err != nil {
		return []string{}
	}
	return files
}

func (a *App) GetPDFFileInfo(localPath string) (PDFFileInfo, error) {
	info, err := os.Stat(localPath)
	if err != nil {
		return PDFFileInfo{}, fmt.Errorf("failed to stat file: %w", err)
	}
	pdfData, err := os.ReadFile(localPath)
	if err != nil {
		return PDFFileInfo{}, fmt.Errorf("failed to read file: %w", err)
	}
	return PDFFileInfo{
		Path:      localPath,
		Size:      info.Size(),
		PageCount: pdfimport.EstimatePageCount(pdfData),
	}, nil
}

type ImportFileInfo struct {
	Path        string `json:"path"`
	Size        int64  `json:"size"`
	PageCount   int    `json:"pageCount"`
	FileType    string `json:"fileType"`
	VisibleName string `json:"visibleName"`
}

func (a *App) GetImportFileInfo(localPath string) (ImportFileInfo, error) {
	info, err := os.Stat(localPath)
	if err != nil {
		return ImportFileInfo{}, fmt.Errorf("failed to stat file: %w", err)
	}

	ext := strings.ToLower(filepath.Ext(localPath))
	switch ext {
	case ".pdf":
		pdfData, err := os.ReadFile(localPath)
		if err != nil {
			return ImportFileInfo{}, fmt.Errorf("failed to read file: %w", err)
		}
		return ImportFileInfo{
			Path:      localPath,
			Size:      info.Size(),
			PageCount: pdfimport.EstimatePageCount(pdfData),
			FileType:  "pdf",
		}, nil
	case ".rmdoc":
		zipData, err := os.ReadFile(localPath)
		if err != nil {
			return ImportFileInfo{}, fmt.Errorf("failed to read file: %w", err)
		}
		rmdocInfo, err := rmdocimport.Inspect(zipData)
		if err != nil {
			return ImportFileInfo{}, fmt.Errorf("failed to inspect rmdoc: %w", err)
		}
		return ImportFileInfo{
			Path:        localPath,
			Size:        info.Size(),
			PageCount:   rmdocInfo.PageCount,
			FileType:    "rmdoc",
			VisibleName: rmdocInfo.VisibleName,
		}, nil
	case ".epub":
		return ImportFileInfo{
			Path:     localPath,
			Size:     info.Size(),
			FileType: "epub",
		}, nil
	default:
		return ImportFileInfo{}, fmt.Errorf("unsupported file type: %s", ext)
	}
}

func (a *App) ImportEpubFromPath(localPath, visibleName string, restartXochitl bool) error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	epubData, err := os.ReadFile(localPath)
	if err != nil {
		return fmt.Errorf("failed to read ePub: %w", err)
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	if _, err := epubimport.Upload(sftpClient, epubData, visibleName, ""); err != nil {
		return err
	}

	if restartXochitl {
		if err := a.RestartXochitl(); err != nil {
			return fmt.Errorf("uploaded, but %w", err)
		}
	}

	return nil
}

func (a *App) ImportRmdocFromPath(localPath, visibleName string, restartXochitl bool) error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	zipData, err := os.ReadFile(localPath)
	if err != nil {
		return fmt.Errorf("failed to read rmdoc: %w", err)
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	if _, err := rmdocimport.Upload(sftpClient, zipData, visibleName); err != nil {
		return err
	}

	if restartXochitl {
		if err := a.RestartXochitl(); err != nil {
			return fmt.Errorf("uploaded, but %w", err)
		}
	}

	return nil
}

// ImportPDFFromPath reads the PDF at localPath, generates xochitl sidecar files,
// and uploads the bundle over the active SFTP connection.
// pageCountOverride can be set to a positive value when auto-detection fails.
func (a *App) ImportPDFFromPath(localPath, visibleName string, restartXochitl bool, pageCountOverride int, coverPageNumber *int) error {
	a.mu.Lock()
	client := a.client
	a.mu.Unlock()

	if client == nil {
		return fmt.Errorf("not connected")
	}

	pdfData, err := os.ReadFile(localPath)
	if err != nil {
		return fmt.Errorf("failed to read PDF: %w", err)
	}

	pageCount := pageCountOverride
	if pageCount <= 0 {
		pageCount = pdfimport.EstimatePageCount(pdfData)
	}
	if pageCount <= 0 {
		return fmt.Errorf("Could not determine page count from PDF.")
	}

	sftpClient, err := sftp.NewClient(client)
	if err != nil {
		return fmt.Errorf("failed to create SFTP client: %w", err)
	}
	defer sftpClient.Close()

	if _, err := pdfimport.Upload(sftpClient, pdfData, visibleName, "", pageCount, coverPageNumber); err != nil {
		return err
	}

	if restartXochitl {
		if err := a.RestartXochitl(); err != nil {
			return fmt.Errorf("uploaded, but %w", err)
		}
	}

	return nil
}

// Input event bytes for BTN_TOUCH (arm64: 24 bytes per event)
// Layout: time_sec(8) + time_usec(8) + type(2) + code(2) + value(4)
var (
	btnTouchDown = []byte{
		0, 0, 0, 0, 0, 0, 0, 0, // time_sec
		0, 0, 0, 0, 0, 0, 0, 0, // time_usec
		0x01, 0x00, // type = EV_KEY (1)
		0x4a, 0x01, // code = BTN_TOUCH (330 = 0x14a)
		0x01, 0x00, 0x00, 0x00, // value = 1 (pressed)
	}
	btnTouchUp = []byte{
		0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0,
		0x01, 0x00,
		0x4a, 0x01,
		0x00, 0x00, 0x00, 0x00, // value = 0 (released)
	}
	synReport = []byte{
		0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0,
		0x00, 0x00, // type = EV_SYN (0)
		0x00, 0x00, // code = SYN_REPORT (0)
		0x00, 0x00, 0x00, 0x00,
	}
)

func (a *App) findPenInputDevice() (string, error) {
	debug.Println("[DEBUG] findPenInputDevice: searching for pen input device via BTN_STYLUS capability")
	// Detect pen device by checking for BTN_STYLUS (331) capability
	// BTN_STYLUS is bit 11 in the first word of key capabilities
	// Pen devices have >= 6 words (64-bit) or >= 11 words (32-bit)
	// Both architectures have BTN_STYLUS in the first printed word
	cmd := `for ev in /sys/class/input/event*; do
		caps=$(cat "$ev/device/capabilities/key" 2>/dev/null)
		[ -z "$caps" ] && continue
		count=$(echo "$caps" | wc -w)
		[ "$count" -lt 6 ] && continue
		first=$(echo "$caps" | awk '{print $1}')
		if [ $((0x$first & 0x800)) -ne 0 ]; then
			echo "/dev/input/$(basename $ev)"
			exit 0
		fi
	done`
	output, err := a.runCommand(cmd)
	if err != nil {
		debug.Printf("[DEBUG] findPenInputDevice: runCommand failed: %v\n", err)
		return "", err
	}
	device := strings.TrimSpace(output)
	debug.Printf("[DEBUG] findPenInputDevice: raw output=%q, device=%q\n", output, device)
	if device == "" {
		return "", fmt.Errorf("pen input device not found (no device with BTN_STYLUS capability)")
	}
	debug.Printf("[DEBUG] findPenInputDevice: found device: %s\n", device)
	return device, nil
}

func (a *App) pokePenDevice(devicePath string, enter bool) error {
	debug.Printf("[DEBUG] pokePenDevice: device=%s enter=%v\n", devicePath, enter)

	var val, dist string
	if enter {
		val = `\001`
		dist = `\062`
	} else {
		val = `\000`
		dist = `\000`
	}

	cmd := fmt.Sprintf(`arch=$(uname -m)
if [ "$arch" = "aarch64" ]; then
  printf '\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\100\001%s\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\031\000%s\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000' > %s
else
  printf '\000\000\000\000\000\000\000\000\003\000\000\000\062\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\003\000\001\000\062\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\003\000\000\000\144\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\003\000\001\000\144\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\001\000\100\001%s\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\003\000\031\000%s\000\000\000' > %s
  printf '\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000' > %s
fi`,
		val, devicePath,
		dist, devicePath,
		devicePath,
		devicePath,
		devicePath,
		devicePath,
		devicePath,
		devicePath,
		val, devicePath,
		dist, devicePath,
		devicePath)

	_, err := a.runCommand(cmd)
	if err != nil {
		debug.Printf("[DEBUG] pokePenDevice: command failed: %v\n", err)
		return err
	}
	debug.Println("[DEBUG] pokePenDevice: successfully wrote events")
	return nil
}

func (a *App) StartPreventSleep() error {
	debug.Println("[DEBUG] StartPreventSleep: called")
	a.mu.Lock()
	if a.preventSleepStop != nil {
		a.mu.Unlock()
		debug.Println("[DEBUG] StartPreventSleep: already running, skipping")
		return nil
	}
	a.mu.Unlock()

	penDevice, err := a.findPenInputDevice()
	if err != nil {
		debug.Printf("[DEBUG] StartPreventSleep: findPenInputDevice failed: %v\n", err)
		return fmt.Errorf("failed to find pen input device: %w", err)
	}

	a.mu.Lock()
	a.penInputDevice = penDevice
	a.preventSleepStop = make(chan struct{})
	stopCh := a.preventSleepStop
	a.mu.Unlock()

	debug.Printf("[DEBUG] StartPreventSleep: starting goroutine for device %s\n", penDevice)
	go func() {
		ticker := time.NewTicker(20 * time.Second)
		defer ticker.Stop()

		for {
			select {
			case <-ticker.C:
				debug.Println("[DEBUG] StartPreventSleep goroutine: pulsing pen proximity")
				if err := a.pokePenDevice(penDevice, true); err != nil {
					debug.Printf("[DEBUG] StartPreventSleep goroutine: pen-enter failed: %v\n", err)
				}
				time.Sleep(50 * time.Millisecond)
				a.pokePenDevice(penDevice, false)
			case <-stopCh:
				debug.Println("[DEBUG] StartPreventSleep goroutine: stopped")
				return
			}
		}
	}()

	runtime.EventsEmit(a.ctx, "prevent-sleep-changed", true)
	debug.Println("[DEBUG] StartPreventSleep: completed successfully")
	return nil
}

func (a *App) StopPreventSleep() error {
	debug.Println("[DEBUG] StopPreventSleep: called")
	a.mu.Lock()
	penDevice := a.penInputDevice
	if a.preventSleepStop != nil {
		debug.Println("[DEBUG] StopPreventSleep: closing stop channel")
		close(a.preventSleepStop)
		a.preventSleepStop = nil
	} else {
		debug.Println("[DEBUG] StopPreventSleep: not running, nothing to stop")
	}
	a.penInputDevice = ""
	a.mu.Unlock()
	if penDevice != "" {
		a.pokePenDevice(penDevice, false)
	}

	runtime.EventsEmit(a.ctx, "prevent-sleep-changed", false)
	return nil
}

func (a *App) IsPreventingSleep() bool {
	a.mu.Lock()
	defer a.mu.Unlock()
	running := a.preventSleepStop != nil
	debug.Printf("[DEBUG] IsPreventingSleep: %v\n", running)
	return running
}

func (a *App) DeleteAllLogs() error {
	if a.logger == nil {
		return nil
	}
	err := a.logger.DeleteAllCommandLogs()
	if err != nil {
		a.logger.LogEvent("APP", "failed to delete command logs: "+err.Error())
		return err
	}
	a.logger.LogEvent("APP", "all command logs deleted by user")
	return nil
}

func (a *App) GetSupportBundlePreview() support.SupportBundlePreview {
	return support.GetPreview()
}

func (a *App) buildGenerator(deviceID string, isConnectedDevice bool, deviceName string) *support.Generator {
	var logDir string
	if a.logger != nil {
		logDir = a.logger.GetLogDir()
	}

	env := runtime.Environment(a.ctx)
	hostOS := env.Platform
	if hostOS == "darwin" {
		hostOS = "macos"
	}
	if platform.IsRunningInFlatpak() {
		hostOS += " (Flatpak)"
	}

	gen := &support.Generator{
		AppVersion: version,
		HostOS:     hostOS,
		LogDir:     logDir,
		DeviceID:   deviceID,
		DeviceName: deviceName,
	}

	settings := a.GetSettings()
	gen.Settings = settings.BehaviorSettings

	if isConnectedDevice {
		deviceInfo := a.GetDeviceInfo()
		if len(deviceInfo) > 0 {
			gen.Device = &support.DeviceInfo{
				MachineType:     deviceInfo["machine"],
				FirmwareVersion: deviceInfo["firmware"],
			}
		}

		if a.vellumClient != nil {
			if versions, err := a.vellumClient.ListInstalledWithVersions(); err == nil {
				gen.InstalledPackages = versions
			}
		}

		osState := a.GetOSVersionState()
		if osState.StoredVersion != "" {
			gen.OSVer = osState.StoredVersion
		}

		updateStatus := a.GetUpdateServiceStatus()
		gen.UpdateService = &support.UpdateServiceStatus{
			Enabled: updateStatus.Enabled,
			Running: updateStatus.Running,
		}

		hashtab := a.CheckHashtabVersion()
		gen.Hashtab = &support.HashtabInfo{
			Installed:      hashtab.Installed,
			HashtabVersion: hashtab.HashtabVersion,
			NeedsRebuild:   hashtab.NeedsRebuild,
		}

		if partInfo, err := a.GetPartitionInfo(); err == nil {
			gen.PartitionInfo = partInfo
		}

		if tz, err := a.GetDeviceTimezone(); err == nil {
			gen.Timezone = tz
		}
	} else if deviceID != "" && a.deviceInfoCache != nil {
		if cached, _ := a.deviceInfoCache.Get(deviceID); cached != nil {
			gen.Device = &support.DeviceInfo{
				MachineType:     cached.MachineType,
				FirmwareVersion: cached.FirmwareVersion,
			}
			gen.InstalledPackages = cached.InstalledPackages
			gen.OSVer = cached.OSVersion
			gen.UpdateService = &support.UpdateServiceStatus{
				Enabled: cached.UpdateServiceEnabled,
				Running: cached.UpdateServiceRunning,
			}
			gen.Hashtab = &support.HashtabInfo{
				Installed:      cached.HashtabInstalled,
				HashtabVersion: cached.HashtabVersion,
				NeedsRebuild:   cached.HashtabNeedsRebuild,
			}
			gen.PartitionInfo = cached.PartitionInfo
			gen.Timezone = cached.Timezone
		}
	}

	return gen
}

func (a *App) GenerateSupportBundle(deviceID string) {
	go func() {
		a.mu.Lock()
		if deviceID == "" {
			deviceID = a.connectedDeviceID
		}
		isConnectedDevice := deviceID == a.connectedDeviceID && a.client != nil
		a.mu.Unlock()

		var deviceName string
		if deviceID != "" && a.deviceStore != nil {
			if d, err := a.deviceStore.Get(deviceID); err == nil {
				deviceName = d.Name
			}
		}

		runtime.EventsEmit(a.ctx, "support-bundle:progress", map[string]string{
			"phase":   "generating",
			"message": "Preparing support bundle...",
		})

		filename := fmt.Sprintf("remanager-support-%s.tar.gz", time.Now().Format("20060102-150405"))
		destPath, err := saveFileDialog(a.ctx, "Save Support Bundle", filename, "")
		if err != nil || destPath == "" {
			if err != nil {
				runtime.EventsEmit(a.ctx, "support-bundle:error", map[string]string{
					"message": err.Error(),
				})
			}
			return
		}

		a.mu.Lock()
		if a.supportBundleID == "" {
			a.supportBundleID = support.GenerateBundleID()
		}
		bundleID := a.supportBundleID
		a.mu.Unlock()

		runtime.EventsEmit(a.ctx, "support-bundle:progress", map[string]string{
			"phase":   "collecting",
			"message": "Collecting device information...",
		})

		gen := a.buildGenerator(deviceID, isConnectedDevice, deviceName)

		if err := gen.Generate(destPath, bundleID); err != nil {
			runtime.EventsEmit(a.ctx, "support-bundle:error", map[string]string{
				"message": fmt.Sprintf("Failed to generate bundle: %v", err),
			})
			return
		}

		if a.logger != nil {
			a.logger.LogEvent("APP", "support bundle generated: "+bundleID)
		}

		runtime.EventsEmit(a.ctx, "support-bundle:complete", map[string]string{
			"path":     destPath,
			"bundleId": bundleID,
		})
	}()
}

func (a *App) UploadSupportBundle(deviceID string) {
	go func() {
		a.mu.Lock()
		if deviceID == "" {
			deviceID = a.connectedDeviceID
		}
		isConnectedDevice := deviceID == a.connectedDeviceID && a.client != nil
		a.mu.Unlock()

		var deviceName string
		if deviceID != "" && a.deviceStore != nil {
			if d, err := a.deviceStore.Get(deviceID); err == nil {
				deviceName = d.Name
			}
		}

		runtime.EventsEmit(a.ctx, "support-bundle:progress", map[string]string{
			"phase":   "generating",
			"message": "Generating support bundle...",
		})

		bundleID := support.GenerateBundleID()
		gen := a.buildGenerator(deviceID, isConnectedDevice, deviceName)

		data, err := gen.GenerateToBuffer(bundleID)
		if err != nil {
			runtime.EventsEmit(a.ctx, "support-bundle:upload-error", map[string]string{
				"message": fmt.Sprintf("Failed to generate bundle: %v", err),
			})
			return
		}

		tmpFile, err := os.CreateTemp("", "remanager-bundle-*.tar.gz")
		if err != nil {
			runtime.EventsEmit(a.ctx, "support-bundle:upload-error", map[string]string{
				"message": fmt.Sprintf("Failed to create temp file: %v", err),
			})
			return
		}
		tmpPath := tmpFile.Name()
		defer os.Remove(tmpPath)

		if _, err := tmpFile.Write(data); err != nil {
			tmpFile.Close()
			runtime.EventsEmit(a.ctx, "support-bundle:upload-error", map[string]string{
				"message": fmt.Sprintf("Failed to write temp file: %v", err),
			})
			return
		}
		tmpFile.Close()

		runtime.EventsEmit(a.ctx, "support-bundle:progress", map[string]string{
			"phase":   "uploading",
			"message": "Uploading support bundle...",
		})

		client := support.NewUploadClient(support.GetSupportURL())
		result, err := client.Upload(tmpPath)
		if err != nil {
			runtime.EventsEmit(a.ctx, "support-bundle:upload-error", map[string]string{
				"message": fmt.Sprintf("Upload failed: %v", err),
			})
			return
		}

		if a.bundleStore != nil {
			a.bundleStore.Add(storage.BundleRecord{
				ID:         bundleID,
				RemoteID:   result.ID,
				URL:        result.URL,
				DeviceName: deviceName,
				DeviceID:   deviceID,
				UploadedAt: time.Now().Unix(),
			}, result.DeleteToken)
		}

		if a.logger != nil {
			a.logger.LogEvent("APP", "support bundle uploaded: "+result.ID)
		}

		runtime.EventsEmit(a.ctx, "support-bundle:upload-complete", map[string]string{
			"url":      result.URL,
			"remoteId": result.ID,
		})
	}()
}

func (a *App) AppendSupportBundle(remoteID, deviceID string) {
	go func() {
		if a.bundleStore == nil {
			runtime.EventsEmit(a.ctx, "support-bundle:append-error", map[string]string{
				"message": "Bundle store not available",
			})
			return
		}

		deleteToken, err := a.bundleStore.GetDeleteToken(remoteID)
		if err != nil {
			runtime.EventsEmit(a.ctx, "support-bundle:append-error", map[string]string{
				"message": "Could not retrieve bundle credentials",
			})
			return
		}

		a.mu.Lock()
		if deviceID == "" {
			deviceID = a.connectedDeviceID
		}
		isConnectedDevice := deviceID == a.connectedDeviceID && a.client != nil
		a.mu.Unlock()

		var deviceName string
		if deviceID != "" && a.deviceStore != nil {
			if d, err := a.deviceStore.Get(deviceID); err == nil {
				deviceName = d.Name
			}
		}

		runtime.EventsEmit(a.ctx, "support-bundle:progress", map[string]string{
			"phase":   "generating",
			"message": "Generating support bundle...",
		})

		bundleID := support.GenerateBundleID()
		gen := a.buildGenerator(deviceID, isConnectedDevice, deviceName)

		data, err := gen.GenerateToBuffer(bundleID)
		if err != nil {
			runtime.EventsEmit(a.ctx, "support-bundle:append-error", map[string]string{
				"message": fmt.Sprintf("Failed to generate bundle: %v", err),
			})
			return
		}

		tmpFile, err := os.CreateTemp("", "remanager-bundle-*.tar.gz")
		if err != nil {
			runtime.EventsEmit(a.ctx, "support-bundle:append-error", map[string]string{
				"message": fmt.Sprintf("Failed to create temp file: %v", err),
			})
			return
		}
		tmpPath := tmpFile.Name()
		defer os.Remove(tmpPath)

		if _, err := tmpFile.Write(data); err != nil {
			tmpFile.Close()
			runtime.EventsEmit(a.ctx, "support-bundle:append-error", map[string]string{
				"message": fmt.Sprintf("Failed to write temp file: %v", err),
			})
			return
		}
		tmpFile.Close()

		runtime.EventsEmit(a.ctx, "support-bundle:progress", map[string]string{
			"phase":   "uploading",
			"message": "Appending to support bundle...",
		})

		client := support.NewUploadClient(support.GetSupportURL())
		_, err = client.Append(tmpPath, remoteID, deleteToken)
		if err != nil {
			runtime.EventsEmit(a.ctx, "support-bundle:append-error", map[string]string{
				"message": fmt.Sprintf("Append failed: %v", err),
			})
			return
		}

		now := time.Now().Unix()
		a.bundleStore.UpdateLastAppended(remoteID, now)

		if a.logger != nil {
			a.logger.LogEvent("APP", "support bundle appended: "+remoteID)
		}

		runtime.EventsEmit(a.ctx, "support-bundle:append-complete", map[string]string{
			"remoteId": remoteID,
		})
	}()
}

func (a *App) DeleteSupportBundle(remoteID string) error {
	if a.bundleStore == nil {
		return fmt.Errorf("bundle store not available")
	}

	deleteToken, err := a.bundleStore.GetDeleteToken(remoteID)
	if err != nil {
		return fmt.Errorf("could not retrieve bundle credentials")
	}

	client := support.NewUploadClient(support.GetSupportURL())
	if err := client.Delete(remoteID, deleteToken); err != nil {
		return err
	}

	return a.bundleStore.Remove(remoteID)
}

func (a *App) GetBundleHistory() []storage.BundleRecord {
	if a.bundleStore == nil {
		return []storage.BundleRecord{}
	}
	records, err := a.bundleStore.GetAll()
	if err != nil {
		return []storage.BundleRecord{}
	}
	return records
}

func (a *App) CopyToClipboard(text string) {
	runtime.ClipboardSetText(a.ctx, text)
}

func (a *App) SubmitProblemReport(description, email, bundleURL, deviceID string) error {
	env := runtime.Environment(a.ctx)
	hostOS := env.Platform
	if hostOS == "darwin" {
		hostOS = "macOS"
	}
	if platform.IsRunningInFlatpak() {
		hostOS += " (Flatpak)"
	}

	a.mu.Lock()
	deviceInfo := make(map[string]string)
	isConnectedDevice := deviceID != "" && deviceID == a.connectedDeviceID && a.client != nil
	a.mu.Unlock()

	if isConnectedDevice {
		deviceInfo = a.GetDeviceInfo()
	} else if deviceID != "" && a.deviceInfoCache != nil {
		if cached, _ := a.deviceInfoCache.Get(deviceID); cached != nil {
			deviceInfo["machine"] = cached.MachineType
			deviceInfo["firmware"] = cached.FirmwareVersion
		}
	}

	report := support.ReportRequest{
		Description: description,
		Email:       email,
		AppVersion:  version,
		HostOS:      hostOS,
		DeviceModel: deviceInfo["machine"],
		Firmware:    deviceInfo["firmware"],
		BundleURL:   bundleURL,
	}

	return support.SubmitReport(support.GetSupportURL(), report)
}

func (a *App) GetSupportBundleSessionID() string {
	a.mu.Lock()
	defer a.mu.Unlock()
	return a.supportBundleID
}

func (a *App) ResetSupportBundleSession() {
	a.mu.Lock()
	a.supportBundleID = ""
	a.mu.Unlock()
}