navi/internal/core/manager.go

package core

import (
	"context"
	"errors"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/url"
	"os"
	"strings"
	"sync"
	"time"

	"vpnclient/internal/config"
	"vpnclient/internal/linknorm"
	"vpnclient/internal/protocols/awg"
	"vpnclient/internal/protocols/hysteria2"
	"vpnclient/internal/protocols/naive"
	"vpnclient/internal/protocols/xray"
	"vpnclient/internal/remnawave"
	"vpnclient/internal/subscription"
	"vpnclient/internal/sysproxy"
)

// Manager orchestrates protocol engines and Windows system proxy.
type Manager struct {
	mu      sync.Mutex
	cfgPath string
	cfg     *config.Config
	engine  Engine
	sys     sysproxy.Controller
	profile *config.Profile
	stderr  io.Writer
	binDir  string
}

func NewManager(cfgPath string, cfg *config.Config, stderr io.Writer) (*Manager, error) {
	if stderr == nil {
		stderr = os.Stderr
	}
	binDir, err := config.ResolveBinDir(cfgPath, cfg.BinDir)
	if err != nil {
		return nil, err
	}
	return &Manager{
		cfgPath: cfgPath,
		cfg:     cfg,
		sys:     sysproxy.New(),
		stderr:  stderr,
		binDir:  binDir,
	}, nil
}

func (m *Manager) Connect(ctx context.Context, profileName string) error {
	m.mu.Lock()
	defer m.mu.Unlock()

	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("already connected; disconnect first")
	}

	if profileName != "" {
		m.cfg.Active = profileName
	}
	profile, err := m.cfg.ActiveProfile()
	if err != nil {
		return err
	}

	engine, err := m.newEngine(profile.Protocol)
	if err != nil {
		return err
	}

	if err := engine.Start(ctx, *profile, m.binDir); err != nil {
		return err
	}

	if m.cfg.SystemProxy {
		httpProxy, ok := engine.LocalHTTPProxy()
		if !ok {
			_ = engine.Stop()
			return fmt.Errorf("system_proxy requires an http:// listen address in the profile")
		}
		if err := m.sys.Enable(httpProxy); err != nil {
			if errors.Is(err, sysproxy.ErrUnsupported) {
				fmt.Fprintf(m.stderr, "system proxy unsupported on this OS; local SOCKS/HTTP still up\n")
			} else {
				_ = engine.Stop()
				return fmt.Errorf("enable system proxy: %w", err)
			}
		}
	}

	m.engine = engine
	m.profile = profile
	return nil
}

func (m *Manager) Disconnect() error {
	m.mu.Lock()
	sys := m.sys
	engine := m.engine
	m.engine = nil
	m.profile = nil
	m.mu.Unlock()

	var first error
	if sys != nil && sys.Enabled() {
		if err := sys.Disable(); err != nil && first == nil {
			first = err
		}
	}
	if engine != nil {
		done := make(chan error, 1)
		go func() { done <- engine.Stop() }()
		select {
		case err := <-done:
			if err != nil && first == nil {
				first = err
			}
		case <-time.After(3 * time.Second):
			// Engine Stop can block on userspace relays; don't freeze the UI.
			if first == nil {
				first = fmt.Errorf("отключение заняло слишком много времени")
			}
		}
	}
	return first
}

func (m *Manager) Status() Status {
	m.mu.Lock()
	defer m.mu.Unlock()

	st := Status{SystemProxy: m.sys.Enabled()}
	if m.engine == nil || !m.engine.Running() {
		return st
	}
	st.Connected = true
	if m.profile != nil {
		st.Profile = m.profile.Name
		st.Protocol = m.profile.Protocol
	}
	if hp, ok := m.engine.LocalHTTPProxy(); ok {
		st.HTTPProxy = hp
	}
	if sp, ok := m.engine.LocalSOCKSProxy(); ok {
		st.SOCKSProxy = sp
	}
	return st
}

// Probe fetches url via the local HTTP or SOCKS proxy to verify the tunnel.
func (m *Manager) Probe(ctx context.Context, testURL string) error {
	m.mu.Lock()
	engine := m.engine
	m.mu.Unlock()
	if engine == nil || !engine.Running() {
		return fmt.Errorf("not connected")
	}
	if testURL == "" {
		testURL = "https://www.google.com/generate_204"
	}

	var proxyURL *url.URL
	if hp, ok := engine.LocalHTTPProxy(); ok {
		proxyURL, _ = url.Parse("http://" + hp)
	} else if sp, ok := engine.LocalSOCKSProxy(); ok {
		proxyURL, _ = url.Parse("socks5://" + sp)
	} else {
		return fmt.Errorf("no local proxy listen address")
	}

	transport := &http.Transport{
		Proxy: http.ProxyURL(proxyURL),
		DialContext: (&net.Dialer{
			Timeout: 15 * time.Second,
		}).DialContext,
		TLSHandshakeTimeout: 15 * time.Second,
		ForceAttemptHTTP2:   true,
	}
	client := &http.Client{
		Transport: transport,
		Timeout:   30 * time.Second,
		CheckRedirect: func(req *http.Request, via []*http.Request) error {
			return http.ErrUseLastResponse
		},
	}
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, testURL, nil)
	if err != nil {
		return err
	}
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("probe via %s: %w", proxyURL.String(), err)
	}
	defer resp.Body.Close()
	if resp.StatusCode >= 400 {
		return fmt.Errorf("probe unexpected status %d", resp.StatusCode)
	}
	return nil
}

func (m *Manager) BinDir() string { return m.binDir }

func (m *Manager) ConfigPath() string { return m.cfgPath }

func (m *Manager) Config() *config.Config {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.cfg
}

func (m *Manager) SetSystemProxy(enabled bool) {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.cfg.SystemProxy = enabled
}

func (m *Manager) UpdateProxyURI(proxy string) error {
	// A plain http(s) URL without credentials is a subscription URL, not a
	// proxy link — run the subscription import instead of failing with
	// "proxy URI missing username".
	if linknorm.LooksLikeSubscriptionURL(proxy) {
		_, err := m.ImportSubscription(proxy)
		return err
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	active, err := m.cfg.ActiveProfile()
	if err != nil {
		return err
	}
	normalized, proto, _, err := linknorm.Normalize(active.Protocol, proxy)
	if err != nil {
		return err
	}
	if err := m.cfg.SetActiveProxy(normalized); err != nil {
		return err
	}
	if proto != "" {
		_ = m.cfg.UpsertProfileWithProtocol(m.cfg.Active, normalized, proto)
	}
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) SetActiveProfile(name string) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	if err := m.cfg.SetActive(name); err != nil {
		return err
	}
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) SaveProfile(name, proxy string) error {
	// Subscription URL pasted into the "add server link" field → import it.
	if linknorm.LooksLikeSubscriptionURL(proxy) {
		_, err := m.ImportSubscription(proxy)
		return err
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	proxy = strings.TrimSpace(proxy)
	var proto config.Protocol
	if proxy != "" {
		normalized, detected, _, err := linknorm.Normalize("", proxy)
		if err != nil {
			return err
		}
		proxy = normalized
		proto = detected
	}
	if err := m.cfg.UpsertProfileWithProtocol(name, proxy, proto); err != nil {
		return err
	}
	if p, err := m.cfg.ActiveProfile(); err == nil {
		hysteria2.EnrichProfile(p)
	}
	return config.Save(m.cfgPath, *m.cfg)
}

// SaveActiveProfile updates the current profile (rename if needed) and proxy URI.
func (m *Manager) SaveActiveProfile(name, proxy string) error {
	// Subscription URL pasted into the profile link field → import it.
	if linknorm.LooksLikeSubscriptionURL(proxy) {
		_, err := m.ImportSubscription(proxy)
		return err
	}
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	name = strings.TrimSpace(name)
	if name == "" {
		return fmt.Errorf("имя профиля пустое")
	}
	proxy = strings.TrimSpace(proxy)
	var proto config.Protocol
	if proxy != "" {
		activeProto := config.Protocol("")
		if p, err := m.cfg.ActiveProfile(); err == nil {
			activeProto = p.Protocol
		}
		normalized, detected, _, err := linknorm.Normalize(activeProto, proxy)
		if err != nil {
			return err
		}
		proxy = normalized
		proto = detected
	}

	active := m.cfg.Active
	if name != active {
		exists := false
		for _, p := range m.cfg.Profiles {
			if p.Name == name {
				exists = true
				break
			}
		}
		if exists {
			if err := m.cfg.SetActive(name); err != nil {
				return err
			}
		} else if err := m.cfg.RenameProfile(active, name); err != nil {
			return err
		}
	}
	if err := m.cfg.UpsertProfileWithProtocol(name, proxy, proto); err != nil {
		return err
	}
	if p, err := m.cfg.ActiveProfile(); err == nil {
		hysteria2.EnrichProfile(p)
	}
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) DeleteProfile(name string) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	if err := m.cfg.DeleteProfile(name); err != nil {
		return err
	}
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) Profiles() []config.ProfileInfo {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.cfg.ListProfiles()
}

// Hy2Options are editable Hysteria 2 extras for the active profile.
type Hy2Options struct {
	Congestion    string `json:"congestion"`
	BBRProfile    string `json:"bbr_profile"`
	BandwidthUp   string `json:"bandwidth_up"`
	BandwidthDown string `json:"bandwidth_down"`
	Obfs          string `json:"obfs"`
	ObfsPassword  string `json:"obfs_password"`
	SNI           string `json:"sni"`
	Insecure      bool   `json:"insecure"`
	PinSHA256     string `json:"pin_sha256"`
	FastOpen      bool   `json:"fast_open"`
	Lazy          bool   `json:"lazy"`
	HopInterval   string `json:"hop_interval"`
}

func (m *Manager) ActiveHy2Options() Hy2Options {
	m.mu.Lock()
	defer m.mu.Unlock()
	p, err := m.cfg.ActiveProfile()
	if err != nil {
		return Hy2Options{Congestion: "bbr", BBRProfile: "standard"}
	}
	return Hy2Options{
		Congestion:    p.Hy2Congestion,
		BBRProfile:    p.Hy2BBRProfile,
		BandwidthUp:   p.Hy2BandwidthUp,
		BandwidthDown: p.Hy2BandwidthDown,
		Obfs:          p.Hy2Obfs,
		ObfsPassword:  p.Hy2ObfsPassword,
		SNI:           p.Hy2SNI,
		Insecure:      p.Hy2Insecure,
		PinSHA256:     p.Hy2PinSHA256,
		FastOpen:      p.Hy2FastOpen,
		Lazy:          p.Hy2Lazy,
		HopInterval:   p.Hy2HopInterval,
	}
}

func (m *Manager) SaveHy2Options(opts Hy2Options) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("сначала отключитесь")
	}
	p, err := m.cfg.ActiveProfile()
	if err != nil {
		return err
	}
	p.Protocol = config.ProtocolHysteria2
	p.Hy2Congestion = strings.TrimSpace(opts.Congestion)
	p.Hy2BBRProfile = strings.TrimSpace(opts.BBRProfile)
	p.Hy2BandwidthUp = strings.TrimSpace(opts.BandwidthUp)
	p.Hy2BandwidthDown = strings.TrimSpace(opts.BandwidthDown)
	p.Hy2Obfs = strings.TrimSpace(opts.Obfs)
	p.Hy2ObfsPassword = strings.TrimSpace(opts.ObfsPassword)
	p.Hy2SNI = strings.TrimSpace(opts.SNI)
	p.Hy2Insecure = opts.Insecure
	p.Hy2PinSHA256 = strings.TrimSpace(opts.PinSHA256)
	p.Hy2FastOpen = opts.FastOpen
	p.Hy2Lazy = opts.Lazy
	p.Hy2HopInterval = strings.TrimSpace(opts.HopInterval)
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) SubscriptionURL() string {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.cfg.SubscriptionURL
}

func (m *Manager) RemnawaveSettings() remnawave.Settings {
	m.mu.Lock()
	defer m.mu.Unlock()
	return remnawave.Settings{
		BaseURL:    m.cfg.RemnawaveBaseURL,
		Token:      m.cfg.RemnawaveToken,
		ShortUUID:  m.cfg.RemnawaveShortUUID,
		CaddyToken: m.cfg.RemnawaveCaddyToken,
	}
}

func (m *Manager) SaveRemnawaveSettings(s remnawave.Settings) error {
	m.mu.Lock()
	defer m.mu.Unlock()
	m.cfg.RemnawaveBaseURL = remnawave.NormalizeBase(s.BaseURL)
	m.cfg.RemnawaveToken = strings.TrimSpace(s.Token)
	m.cfg.RemnawaveShortUUID = strings.TrimSpace(s.ShortUUID)
	m.cfg.RemnawaveCaddyToken = strings.TrimSpace(s.CaddyToken)
	return config.Save(m.cfgPath, *m.cfg)
}

// ImportResult reports how a subscription import went.
type ImportResult struct {
	Imported int      `json:"imported"`
	Skipped  int      `json:"skipped"`
	Warnings []string `json:"warnings,omitempty"`
}

func (m *Manager) ImportSubscription(rawURL string) (ImportResult, error) {
	rawURL = strings.TrimSpace(rawURL)
	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
	defer cancel()

	// Remnawave-style URL → persist panel coords and fetch via API helper.
	if base, short, ok := remnawave.ParseInput(rawURL); ok {
		s := remnawave.Settings{
			BaseURL:    base,
			ShortUUID:  short,
			Token:      m.RemnawaveSettings().Token,
			CaddyToken: m.RemnawaveSettings().CaddyToken,
		}
		res, used, err := remnawave.Fetch(ctx, s)
		if err != nil {
			return ImportResult{}, err
		}
		return m.applySubscription(ctx, res, used, &s)
	}

	res, err := subscription.Fetch(ctx, rawURL)
	if err != nil {
		return ImportResult{}, err
	}
	return m.applySubscription(ctx, res, rawURL, nil)
}

// ImportRemnawave fetches configs using saved / provided panel settings.
func (m *Manager) ImportRemnawave(s remnawave.Settings) (ImportResult, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
	defer cancel()
	if strings.TrimSpace(s.BaseURL) == "" || strings.TrimSpace(s.ShortUUID) == "" {
		cur := m.RemnawaveSettings()
		if strings.TrimSpace(s.BaseURL) == "" {
			s.BaseURL = cur.BaseURL
		}
		if strings.TrimSpace(s.ShortUUID) == "" {
			s.ShortUUID = cur.ShortUUID
		}
		if strings.TrimSpace(s.Token) == "" {
			s.Token = cur.Token
		}
		if strings.TrimSpace(s.CaddyToken) == "" {
			s.CaddyToken = cur.CaddyToken
		}
	}
	res, used, err := remnawave.Fetch(ctx, s)
	if err != nil {
		return ImportResult{}, err
	}
	return m.applySubscription(ctx, res, used, &s)
}

func (m *Manager) applySubscription(ctx context.Context, res *subscription.Result, usedURL string, rw *remnawave.Settings) (ImportResult, error) {
	if res == nil || len(res.Items) == 0 {
		if res != nil && res.Skipped > 0 {
			return ImportResult{Skipped: res.Skipped, Warnings: res.Warnings},
				fmt.Errorf("нет валидных серверов: %d записей пропущено (%s)", res.Skipped, strings.Join(res.Warnings, "; "))
		}
		return ImportResult{}, fmt.Errorf("в подписке нет поддерживаемых ссылок (naive / hysteria2 / awg / vless / vmess / trojan)")
	}

	// Subscription usage info: header data first, enriched via Remnawave API
	// (devices / limits) when an API token is configured. Best-effort.
	subInfo := buildSubInfo(res.Info)
	{
		s := m.RemnawaveSettings()
		if rw != nil {
			s = *rw
			if strings.TrimSpace(s.Token) == "" {
				s.Token = m.RemnawaveSettings().Token
			}
		}
		if strings.TrimSpace(s.Token) != "" && strings.TrimSpace(s.BaseURL) != "" && strings.TrimSpace(s.ShortUUID) != "" {
			if ui, err := remnawave.FetchUserInfo(ctx, s); err == nil && ui != nil {
				if subInfo == nil {
					subInfo = &config.SubscriptionInfo{}
				}
				if subInfo.Upload == 0 && subInfo.Download == 0 && ui.UsedTraffic > 0 {
					subInfo.Download = ui.UsedTraffic
				}
				if subInfo.Total == 0 && ui.TrafficLimit > 0 {
					subInfo.Total = ui.TrafficLimit
				}
				if subInfo.Expire == 0 && ui.ExpireAt > 0 {
					subInfo.Expire = ui.ExpireAt
				}
				subInfo.DevicesKnown = ui.DevicesKnown
				subInfo.Devices = ui.Devices
				subInfo.DeviceLimit = ui.DeviceLimit
			}
		}
	}
	if subInfo != nil {
		subInfo.UpdatedAt = time.Now().Unix()
	}

	m.mu.Lock()
	defer m.mu.Unlock()
	if usedURL != "" {
		m.cfg.SubscriptionURL = strings.TrimSpace(usedURL)
	}
	if rw != nil {
		m.cfg.RemnawaveBaseURL = remnawave.NormalizeBase(rw.BaseURL)
		m.cfg.RemnawaveShortUUID = strings.TrimSpace(rw.ShortUUID)
		if t := strings.TrimSpace(rw.Token); t != "" {
			m.cfg.RemnawaveToken = t
		}
		if t := strings.TrimSpace(rw.CaddyToken); t != "" {
			m.cfg.RemnawaveCaddyToken = t
		}
	}
	if subInfo != nil {
		m.cfg.SubInfo = subInfo
	}
	for _, it := range res.Items {
		_ = m.cfg.UpsertProfileWithProtocol(it.Name, it.URI, it.Protocol)
		for i := range m.cfg.Profiles {
			if m.cfg.Profiles[i].Name == it.Name {
				hysteria2.EnrichProfile(&m.cfg.Profiles[i])
				break
			}
		}
	}
	if err := config.Save(m.cfgPath, *m.cfg); err != nil {
		return ImportResult{}, err
	}
	return ImportResult{Imported: len(res.Items), Skipped: res.Skipped, Warnings: res.Warnings}, nil
}

// ProvisionOutcome is what the UI shows after issuing access via the panel.
type ProvisionOutcome struct {
	Username          string `json:"username"`
	Created           bool   `json:"created"`
	SubscriptionURL   string `json:"subscription_url"`
	TrafficLimitBytes int64  `json:"traffic_limit_bytes,omitempty"`
	ExpireAt          int64  `json:"expire_at,omitempty"`
	Imported          int    `json:"imported"`
	Skipped           int    `json:"skipped"`
}

// ProvisionConfigured reports whether configs/remnawave-api.json exists —
// the admin "Выдать доступ" panel is shown only in that case.
func (m *Manager) ProvisionConfigured() bool {
	st, err := os.Stat(remnawave.AdminConfigPath(m.cfgPath))
	return err == nil && !st.IsDir()
}

// ProvisionAccess creates (or finds) a panel user via the Remnawave admin API
// and imports its subscription configs into the app.
func (m *Manager) ProvisionAccess(username string) (ProvisionOutcome, error) {
	cfg, err := remnawave.LoadAdminConfig(remnawave.AdminConfigPath(m.cfgPath))
	if err != nil {
		return ProvisionOutcome{}, err
	}
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	defer cancel()
	res, err := remnawave.ProvisionUser(ctx, cfg, username)
	if err != nil {
		return ProvisionOutcome{}, err
	}
	out := ProvisionOutcome{
		Username:          res.Username,
		Created:           res.Created,
		SubscriptionURL:   res.SubscriptionURL,
		TrafficLimitBytes: res.TrafficLimitBytes,
		ExpireAt:          res.ExpireAt,
	}
	subURL := res.SubscriptionURL
	if subURL == "" && res.ShortUUID != "" {
		subURL = remnawave.PublicSubURL(cfg.PanelURL, res.ShortUUID)
		out.SubscriptionURL = subURL
	}
	if subURL == "" {
		return out, fmt.Errorf("панель не вернула subscription URL для %s", res.Username)
	}
	imp, err := m.ImportSubscription(subURL)
	if err != nil {
		return out, fmt.Errorf("доступ выдан (%s), но импорт конфигов не удался: %w", res.Username, err)
	}
	out.Imported = imp.Imported
	out.Skipped = imp.Skipped
	return out, nil
}

func buildSubInfo(info *subscription.Info) *config.SubscriptionInfo {
	if info == nil {
		return nil
	}
	return &config.SubscriptionInfo{
		Upload:   info.Upload,
		Download: info.Download,
		Total:    info.Total,
		Expire:   info.Expire,
	}
}

// SubscriptionInfo returns the cached subscription usage info (may be nil).
func (m *Manager) SubscriptionInfo() *config.SubscriptionInfo {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.cfg.SubInfo == nil {
		return nil
	}
	cp := *m.cfg.SubInfo
	return &cp
}

func (m *Manager) SaveConfig() error {
	m.mu.Lock()
	defer m.mu.Unlock()
	return config.Save(m.cfgPath, *m.cfg)
}

func (m *Manager) Reload() error {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.engine != nil && m.engine.Running() {
		return fmt.Errorf("disconnect before reloading config")
	}
	cfg, err := config.Load(m.cfgPath)
	if err != nil {
		return err
	}
	binDir, err := config.ResolveBinDir(m.cfgPath, cfg.BinDir)
	if err != nil {
		return err
	}
	m.cfg = cfg
	m.binDir = binDir
	return nil
}

func (m *Manager) newEngine(p config.Protocol) (Engine, error) {
	switch p {
	case config.ProtocolNaive, "":
		return naive.New(m.stderr), nil
	case config.ProtocolHysteria2:
		return hysteria2.New(m.stderr), nil
	case config.ProtocolAWG:
		return awg.New(m.stderr), nil
	case config.ProtocolVLESS, config.ProtocolVMess, config.ProtocolTrojan:
		return xray.New(m.stderr), nil
	default:
		return nil, fmt.Errorf("unsupported protocol %q", p)
	}
}

// EnsureCore downloads the binary required by the active (or given) protocol.
func (m *Manager) EnsureCore(proto config.Protocol) (string, error) {
	if proto == "" {
		if p, err := m.cfg.ActiveProfile(); err == nil {
			proto = p.Protocol
		}
	}
	switch proto {
	case config.ProtocolHysteria2:
		return hysteria2.EnsureBinary(m.binDir)
	case config.ProtocolAWG:
		return awg.EnsureBinary(m.binDir)
	case config.ProtocolVLESS, config.ProtocolVMess, config.ProtocolTrojan:
		return xray.EnsureBinary(m.binDir)
	default:
		return naive.EnsureBinary(m.binDir)
	}
}

// EnsureAllCores installs naive + hysteria2 + xray cores (AWG is embedded).
func (m *Manager) EnsureAllCores() (map[string]string, error) {
	out := map[string]string{}
	p1, err := naive.EnsureBinary(m.binDir)
	if err != nil {
		return out, fmt.Errorf("naive: %w", err)
	}
	out["naive"] = p1
	p2, err := hysteria2.EnsureBinary(m.binDir)
	if err != nil {
		return out, fmt.Errorf("hysteria2: %w", err)
	}
	out["hysteria2"] = p2
	p3, err := awg.EnsureBinary(m.binDir)
	if err != nil {
		return out, fmt.Errorf("awg: %w", err)
	}
	out["awg"] = p3
	p4, err := xray.EnsureBinary(m.binDir)
	if err != nil {
		return out, fmt.Errorf("xray: %w", err)
	}
	out["xray"] = p4
	return out, nil
}