main.go

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io/fs"
	"os"
	"os/exec"
	"os/signal"
	"path/filepath"
	"strings"
	"syscall"
	"time"
)

const version = "0.1.0"

type LauncherConfig struct {
	WorkingDir     string   `json:"working_dir"`
	UsqueBinary    string   `json:"usque_binary"`
	UsqueConfig    string   `json:"usque_config"`
	UsqueMode      string   `json:"usque_mode"`
	ListenHost     string   `json:"listen_host"`
	ListenPort     int      `json:"listen_port"`
	Username       string   `json:"username"`
	Password       string   `json:"password"`
	UsqueExtraArgs []string `json:"usque_extra_args"`

	StartSingBox  bool     `json:"start_singbox"`
	SingBoxBinary string   `json:"singbox_binary"`
	SingBoxConfig string   `json:"singbox_config"`
	SingBoxArgs   []string `json:"singbox_args"`
}

type loadedConfig struct {
	Path   string
	Dir    string
	Config LauncherConfig
}

func defaultConfig() LauncherConfig {
	return LauncherConfig{
		UsqueBinary:    "usque.exe",
		UsqueConfig:    "config.json",
		UsqueMode:      "socks",
		ListenHost:     "127.0.0.1",
		ListenPort:     1080,
		UsqueExtraArgs: []string{},
		StartSingBox:   false,
		SingBoxBinary:  "sing-box.exe",
		SingBoxConfig:  "sing-box-via-usque.json",
		SingBoxArgs:    []string{},
	}
}

func main() {
	if len(os.Args) < 2 {
		printUsage()
		os.Exit(1)
	}

	switch os.Args[1] {
	case "init":
		must(runInit(os.Args[2:]))
	case "doctor":
		must(runDoctor(os.Args[2:]))
	case "register":
		must(runUsquePassthrough("register", os.Args[2:]))
	case "enroll":
		must(runUsquePassthrough("enroll", os.Args[2:]))
	case "run":
		must(runLaunch(os.Args[2:]))
	case "version":
		fmt.Println(version)
	case "help":
		printUsage()
	default:
		fmt.Fprintf(os.Stderr, "Неизвестная команда: %s\n\n", os.Args[1])
		printUsage()
		os.Exit(1)
	}
}

func must(err error) {
	if err == nil {
		return
	}
	fmt.Fprintln(os.Stderr, "Ошибка:", err)
	os.Exit(1)
}

func printUsage() {
	fmt.Printf(`Usque / Sing-box launcher v%s

Команды:
  help      показать эту справку
  init      создать launcher.json и пример конфигурации sing-box
  doctor    проверить файлы и базовую совместимость
  register  вызвать "usque register" с конфигом из launcher.json
  enroll    вызвать "usque enroll" с конфигом из launcher.json
  run       запустить usque и, опционально, sing-box
  version   показать версию

Флаги команды run:
  --config <path>    путь к launcher.json
  --with-singbox     запустить usque + sing-box (переопределяет start_singbox)

Общий флаг:
  --config <path>   путь к launcher.json

Примеры:
  usque-warp-launcher.exe init
  usque-warp-launcher.exe register
  usque-warp-launcher.exe run
  usque-warp-launcher.exe run --with-singbox
  usque-warp-launcher.exe doctor --config launcher.json
`, version)
}

func runInit(args []string) error {
	configPath := "launcher.json"
	for i := 0; i < len(args); i++ {
		if args[i] == "--config" && i+1 < len(args) {
			configPath = args[i+1]
			i++
		} else if strings.HasPrefix(args[i], "--config=") {
			configPath = strings.TrimPrefix(args[i], "--config=")
		}
	}

	cfgAbs, err := filepath.Abs(configPath)
	if err != nil {
		return err
	}
	cfgDir := filepath.Dir(cfgAbs)
	if err := os.MkdirAll(cfgDir, 0o755); err != nil {
		return err
	}

	if err := writeJSONIfMissing(cfgAbs, defaultConfig()); err != nil {
		return err
	}

	singBoxConfigPath := filepath.Join(cfgDir, "sing-box-via-usque.json")
	singBoxExamplePath := filepath.Join(cfgDir, "sing-box-via-usque.example.json")

	if err := writeJSONIfMissing(singBoxConfigPath, defaultSingBoxExample()); err != nil {
		return err
	}
	if err := writeJSONIfMissing(singBoxExamplePath, defaultSingBoxExample()); err != nil {
		return err
	}

	fmt.Println("Созданы файлы:")
	fmt.Println(" -", cfgAbs)
	fmt.Println(" -", singBoxConfigPath)
	fmt.Println(" -", singBoxExamplePath)
	fmt.Println()
	fmt.Println("Дальше:")
	fmt.Println("  1. Положите рядом usque.exe")
	fmt.Println("  2. Выполните: usque-warp-launcher.exe register")
	fmt.Println("  3. Запустите: usque-warp-launcher.exe run --with-singbox")
	return nil
}

func runDoctor(args []string) error {
	loaded, err := loadConfigFromArgs("doctor", args)
	if err != nil {
		return err
	}

	cfg := loaded.Config
	usquePath := resolvePath(loaded.Dir, cfg.UsqueBinary)
	usqueConfigPath := resolvePath(loaded.Dir, cfg.UsqueConfig)
	singBoxPath := resolvePath(loaded.Dir, cfg.SingBoxBinary)
	singBoxConfigPath := resolvePath(loaded.Dir, cfg.SingBoxConfig)

	if err := validateConfig(cfg); err != nil {
		return err
	}

	printFileStatus("usque.exe", usquePath, true)
	printFileStatus("usque config", usqueConfigPath, false)

	if cfg.StartSingBox {
		printFileStatus("sing-box.exe", singBoxPath, true)
		printFileStatus("sing-box config", singBoxConfigPath, true)
	} else {
		fmt.Println(" - sing-box: отключен в launcher.json")
	}

	return nil
}

func runUsquePassthrough(subcommand string, args []string) error {
	loaded, extraArgs, err := loadConfigAndExtraArgs(subcommand, args)
	if err != nil {
		return err
	}

	cfg := loaded.Config
	if err := validateConfig(cfg); err != nil {
		return err
	}

	usquePath := resolvePath(loaded.Dir, cfg.UsqueBinary)
	baseArgs := []string{"-c", resolvePath(loaded.Dir, cfg.UsqueConfig), subcommand}
	baseArgs = append(baseArgs, extraArgs...)

	fmt.Printf("Запуск: %s %s\n", usquePath, strings.Join(baseArgs, " "))
	cmd := exec.Command(usquePath, baseArgs...)
	cmd.Dir = workingDir(loaded)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.Stdin = os.Stdin
	return cmd.Run()
}

func runLaunch(args []string) error {
	withSingBox, runArgs := extractWithSingBox(args)

	loaded, err := loadConfigFromArgs("run", runArgs)
	if err != nil {
		return err
	}

	cfg := loaded.Config
	if withSingBox {
		cfg.StartSingBox = true
	}
	if err := validateConfig(cfg); err != nil {
		return err
	}

	usquePath := resolvePath(loaded.Dir, cfg.UsqueBinary)
	usqueArgs, err := buildUsqueRunArgs(loaded)
	if err != nil {
		return err
	}

	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
	defer stop()

	fmt.Printf("Старт usque: %s %s\n", usquePath, strings.Join(usqueArgs, " "))
	usqueCmd := exec.CommandContext(ctx, usquePath, usqueArgs...)
	usqueCmd.Dir = workingDir(loaded)
	usqueCmd.Stdout = os.Stdout
	usqueCmd.Stderr = os.Stderr
	usqueCmd.Stdin = os.Stdin

	if err := usqueCmd.Start(); err != nil {
		return fmt.Errorf("не удалось запустить usque: %w", err)
	}

	done := make(chan error, 2)
	go func() {
		done <- wrapExit("usque", usqueCmd.Wait())
	}()

	var singBoxCmd *exec.Cmd
	if cfg.StartSingBox {
		time.Sleep(1500 * time.Millisecond)

		singBoxPath := resolvePath(loaded.Dir, cfg.SingBoxBinary)
		singBoxArgs := buildSingBoxArgs(loaded)
		fmt.Printf("Старт sing-box: %s %s\n", singBoxPath, strings.Join(singBoxArgs, " "))

		singBoxCmd = exec.CommandContext(ctx, singBoxPath, singBoxArgs...)
		singBoxCmd.Dir = workingDir(loaded)
		singBoxCmd.Stdout = os.Stdout
		singBoxCmd.Stderr = os.Stderr
		singBoxCmd.Stdin = os.Stdin

		if err := singBoxCmd.Start(); err != nil {
			_ = terminateProcess(usqueCmd.Process)
			return fmt.Errorf("не удалось запустить sing-box: %w", err)
		}

		go func() {
			done <- wrapExit("sing-box", singBoxCmd.Wait())
		}()
	}

	expected := 1
	if singBoxCmd != nil {
		expected = 2
	}

	for i := 0; i < expected; i++ {
		select {
		case <-ctx.Done():
			fmt.Println("\nПолучен сигнал остановки, завершаю процессы...")
			if singBoxCmd != nil {
				_ = terminateProcess(singBoxCmd.Process)
			}
			_ = terminateProcess(usqueCmd.Process)
			time.Sleep(300 * time.Millisecond)
			return nil
		case err := <-done:
			if err != nil {
				if singBoxCmd != nil {
					_ = terminateProcess(singBoxCmd.Process)
				}
				_ = terminateProcess(usqueCmd.Process)
				return err
			}
		}
	}

	return nil
}

func extractWithSingBox(args []string) (bool, []string) {
	remaining := make([]string, 0, len(args))
	with := false
	for _, a := range args {
		switch a {
		case "-with-singbox", "--with-singbox":
			with = true
		default:
			remaining = append(remaining, a)
		}
	}
	return with, remaining
}

func loadConfigFromArgs(name string, args []string) (loadedConfig, error) {
	configPath := "launcher.json"
	for i := 0; i < len(args); i++ {
		if args[i] == "--config" && i+1 < len(args) {
			configPath = args[i+1]
			i++
		} else if strings.HasPrefix(args[i], "--config=") {
			configPath = strings.TrimPrefix(args[i], "--config=")
		}
	}
	return loadConfig(configPath)
}

func loadConfigAndExtraArgs(name string, args []string) (loadedConfig, []string, error) {
	configPath, passthroughArgs, err := splitLauncherConfigArgs(args)
	if err != nil {
		return loadedConfig{}, nil, err
	}
	loaded, err := loadConfig(configPath)
	if err != nil {
		return loadedConfig{}, nil, err
	}
	return loaded, passthroughArgs, nil
}

func splitLauncherConfigArgs(args []string) (string, []string, error) {
	configPath := "launcher.json"
	passthroughArgs := make([]string, 0, len(args))

	for i := 0; i < len(args); i++ {
		arg := args[i]
		switch {
		case arg == "--config":
			if i+1 >= len(args) {
				return "", nil, fmt.Errorf("ожидалось значение после %s", arg)
			}
			configPath = args[i+1]
			i++
		case strings.HasPrefix(arg, "--config="):
			configPath = strings.TrimPrefix(arg, "--config=")
		default:
			passthroughArgs = append(passthroughArgs, arg)
		}
	}

	return configPath, passthroughArgs, nil
}

func loadConfig(path string) (loadedConfig, error) {
	absPath, err := filepath.Abs(path)
	if err != nil {
		return loadedConfig{}, err
	}
	data, err := os.ReadFile(absPath)
	if err != nil {
		return loadedConfig{}, fmt.Errorf("не удалось прочитать launcher.json: %w", err)
	}

	cfg := defaultConfig()
	if err := json.Unmarshal(data, &cfg); err != nil {
		return loadedConfig{}, fmt.Errorf("launcher.json поврежден: %w", err)
	}

	if err := validateConfig(cfg); err != nil {
		return loadedConfig{}, err
	}

	return loadedConfig{
		Path:   absPath,
		Dir:    filepath.Dir(absPath),
		Config: cfg,
	}, nil
}

func validateConfig(cfg LauncherConfig) error {
	switch strings.ToLower(cfg.UsqueMode) {
	case "socks", "http-proxy", "nativetun":
	default:
		return fmt.Errorf("неподдерживаемый usque_mode: %q (ожидается socks, http-proxy или nativetun)", cfg.UsqueMode)
	}

	if cfg.UsqueBinary == "" {
		return errors.New("поле usque_binary не должно быть пустым")
	}
	if cfg.UsqueConfig == "" {
		return errors.New("поле usque_config не должно быть пустым")
	}
	if cfg.ListenPort < 0 || cfg.ListenPort > 65535 {
		return errors.New("listen_port должен быть в диапазоне 0..65535")
	}
	if cfg.StartSingBox && cfg.SingBoxBinary == "" {
		return errors.New("поле singbox_binary не должно быть пустым, если start_singbox=true")
	}
	if cfg.StartSingBox && cfg.SingBoxConfig == "" && len(cfg.SingBoxArgs) == 0 {
		return errors.New("нужно указать singbox_config или singbox_args, если start_singbox=true")
	}
	return nil
}

func writeJSONIfMissing(path string, value any) error {
	if _, err := os.Stat(path); err == nil {
		fmt.Println("Файл уже существует, пропускаю:", path)
		return nil
	} else if !errors.Is(err, fs.ErrNotExist) {
		return err
	}

	data, err := json.MarshalIndent(value, "", "  ")
	if err != nil {
		return err
	}
	data = append(data, '\n')
	return os.WriteFile(path, data, 0o644)
}

func defaultSingBoxExample() map[string]any {
	return map[string]any{
		"log": map[string]any{
			"level": "info",
		},
		"dns": map[string]any{
			"servers": []map[string]any{
				{
					"tag":    "cloudflare",
					"type":   "tls",
					"server": "1.1.1.1",
				},
			},
		},
		"inbounds": []map[string]any{
			{
				"type":           "tun",
				"tag":            "tun-in",
				"interface_name": "sb-tun",
				"address":        []string{"172.19.0.1/30"},
				"auto_route":     true,
				"strict_route":   false,
				"stack":          "system",
			},
		},
		"outbounds": []map[string]any{
			{
				"type":        "socks",
				"tag":         "usque-out",
				"server":      "127.0.0.1",
				"server_port": 1080,
				"version":     "5",
			},
			{
				"type": "direct",
				"tag":  "direct",
			},
		},
		"route": map[string]any{
			"auto_detect_interface": true,
			"rules": []map[string]any{
				{
					"ip_cidr": []string{
						"162.159.198.0/24",
						"162.159.61.0/24",
						"188.114.96.0/24",
						"188.114.97.0/24",
					},
					"outbound": "direct",
				},
				{
					"protocol": "dns",
					"outbound": "direct",
				},
			},
			"final": "usque-out",
		},
	}
}

func buildUsqueRunArgs(loaded loadedConfig) ([]string, error) {
	cfg := loaded.Config
	args := []string{"-c", resolvePath(loaded.Dir, cfg.UsqueConfig), cfg.UsqueMode}

	if cfg.ListenHost != "" && cfg.UsqueMode != "nativetun" {
		args = append(args, "-b", cfg.ListenHost)
	}
	if cfg.ListenPort > 0 && cfg.UsqueMode != "nativetun" {
		args = append(args, "-p", fmt.Sprintf("%d", cfg.ListenPort))
	}
	if cfg.Username != "" && cfg.UsqueMode != "nativetun" {
		args = append(args, "-u", cfg.Username)
	}
	if cfg.Password != "" && cfg.UsqueMode != "nativetun" {
		args = append(args, "-w", cfg.Password)
	}

	args = append(args, cfg.UsqueExtraArgs...)
	return args, nil
}

func buildSingBoxArgs(loaded loadedConfig) []string {
	cfg := loaded.Config
	if len(cfg.SingBoxArgs) > 0 {
		return cfg.SingBoxArgs
	}
	return []string{"run", "-c", resolvePath(loaded.Dir, cfg.SingBoxConfig)}
}

func workingDir(loaded loadedConfig) string {
	if strings.TrimSpace(loaded.Config.WorkingDir) == "" {
		return loaded.Dir
	}
	return resolvePath(loaded.Dir, loaded.Config.WorkingDir)
}

func resolvePath(baseDir, path string) string {
	if path == "" {
		return ""
	}
	if filepath.IsAbs(path) {
		return path
	}
	return filepath.Join(baseDir, path)
}

func wrapExit(name string, err error) error {
	if err == nil {
		return nil
	}
	return fmt.Errorf("%s завершился с ошибкой: %w", name, err)
}

func terminateProcess(p *os.Process) error {
	if p == nil {
		return nil
	}
	return p.Kill()
}

func printFileStatus(name, path string, required bool) {
	_, err := os.Stat(path)
	switch {
	case err == nil:
		fmt.Println(" -", name+":", "OK ->", path)
	case errors.Is(err, fs.ErrNotExist):
		if required {
			fmt.Println(" -", name+":", "НЕ НАЙДЕН ->", path)
		} else {
			fmt.Println(" -", name+":", "не найден (появится после register) ->", path)
		}
	default:
		fmt.Println(" -", name+":", "ошибка проверки ->", err)
	}
}