main.go

package main

import (
	"fmt"
	"os"
	"os/exec"
	"os/signal"
	"runtime"
	"strings"
	"syscall"

	"github.com/codeskyblue/iosbridge/usbmuxd"
	log "github.com/sirupsen/logrus"
	"github.com/urfave/cli/v2"
)

const (
	ServerPort = 55933
)

func setupLogging(c *cli.Context) error {
	// Configure logging based on verbosity flags
	log.SetFormatter(&log.TextFormatter{
		FullTimestamp: true,
	})

	// Default level is Info
	logLevel := log.InfoLevel

	// Set Debug level if verbose flag is set
	if c.Bool("verbose") {
		logLevel = log.DebugLevel
	}

	log.SetLevel(logLevel)
	return nil
}

func main() {
	app := &cli.App{
		Name:    "iosbridge",
		Usage:   "iOS device remote debugging support",
		Version: VERSION_NAME,
		Authors: []*cli.Author{
			{
				Name:  "codeskyblue",
				Email: "codeskyblue@gmail.com",
			},
		},
		Flags: []cli.Flag{
			&cli.BoolFlag{
				Name:  "verbose",
				Usage: "Enable verbose logging",
			},
		},
		Before: setupLogging,
		Commands: []*cli.Command{
			{
				Name:   "usbtotcp",
				Usage:  "Connect device side and expose through TCP",
				Action: usbToTcpAction,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "udid",
						Aliases:  []string{"u"},
						Usage:    "Device UDID",
						Required: true,
					},
					&cli.IntFlag{
						Name:     "port",
						Aliases:  []string{"p"},
						Usage:    "TCP port to listen on",
						Required: true,
					},
				},
			},
			{
				Name:   "start-server",
				Usage:  "Start the iosbridge server",
				Action: startServerAction,
				Flags: []cli.Flag{
					&cli.BoolFlag{
						Name:    "foreground",
						Aliases: []string{"f"},
						Usage:   "Run in foreground",
					},
				},
			},
			{
				Name:      "connect",
				Usage:     "Connect to a remote device",
				Action:    connectAction,
				ArgsUsage: "<remote-ip>:<port>",
			},
			{
				Name:      "disconnect",
				Usage:     "Disconnect from a remote device",
				Action:    disconnectAction,
				ArgsUsage: "<remote-ip>:<port>",
			},
			{
				Name:   "devices",
				Usage:  "List connected devices",
				Action: devicesAction,
			},
			{
				Name:   "kill-server",
				Usage:  "Stop the iosbridge server",
				Action: killServerAction,
			},
			// {
			// 	Name:   "mock-server",
			// 	Usage:  "Start a mock usbmuxd server",
			// 	Action: mockServerAction,
			// },
			// {
			// 	Name:   "test-client",
			// 	Usage:  "Test usbmuxd client",
			// 	Action: testClientAction,
			// },
		},
	}

	if err := app.Run(os.Args); err != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
		os.Exit(1)
	}
}

func usbToTcpAction(c *cli.Context) error {
	udid := c.String("udid")
	port := c.Int("port")

	fmt.Printf("Starting USB to TCP bridge for device %s on port %d\n", udid, port)

	// Implement the USB to TCP bridge
	return startUsbToTcp(udid, port)
}

func startServerAction(c *cli.Context) error {
	foreground := c.Bool("foreground")
	if !foreground {
		// Run as daemon by default
		args := []string{"start-server", "--foreground"}

		var cmd *exec.Cmd
		if os.Geteuid() != 0 { // not as root
			// Use syscall.Exec to replace the current process with sudo
			sudoPath, err := exec.LookPath("sudo")
			if err != nil {
				return fmt.Errorf("sudo not found: %v", err)
			}
			return syscall.Exec(sudoPath, append([]string{"sudo", os.Args[0]}, "start-server"), os.Environ())
		}
		cmd = exec.Command(os.Args[0], args...)

		// Redirect output to log file
		logFile, err := os.OpenFile("iosbridge.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
		if err != nil {
			return fmt.Errorf("failed to open log file: %v", err)
		}
		cmd.Stdout = logFile
		cmd.Stderr = logFile
		devNull, err := os.Open(os.DevNull)
		if err != nil {
			return fmt.Errorf("failed to open /dev/null: %v", err)
		}
		cmd.Stdin = devNull

		cmd.Env = os.Environ()
		err = cmd.Start()
		if err != nil {
			return fmt.Errorf("failed to start daemon: %v", err)
		}
		fmt.Println("Server started in background")
		return nil
	}
	return startServerForeground()
}

func startServerForeground() error {
	fmt.Println("Starting iosbridge server...")

	// Check if running as root
	if os.Geteuid() != 0 {
		return fmt.Errorf("this command requires root privileges")
	}

	if isServerRunning() {
		return fmt.Errorf("server already running")
	}
	httpMuxServer := NewHTTPMuxServer()
	if runtime.GOOS == "darwin" && usbmuxd.IsUnixSocket(UsbmuxdPath) {
		log.Infof("Moving existing unix socket %s to %s", UsbmuxdPath, UsbmuxdBackupPath)
		os.Rename(UsbmuxdPath, UsbmuxdBackupPath)
		httpMuxServer.hub.AddSocketAddress("unix://" + UsbmuxdBackupPath)
		defer func() {
			log.Infof("Restoring unix socket %s from %s", UsbmuxdPath, UsbmuxdBackupPath)
			os.Rename(UsbmuxdBackupPath, UsbmuxdPath)
		}()
	}

	// handle quit signal
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)

	go func() {
		sig := <-sigChan
		if sig == syscall.SIGHUP {
			// Ignore SIGHUP to keep running when terminal closes
			log.Infof("Received SIGHUP, ignoring...")
			return
		}
		fmt.Printf("Received signal %v, shutting down...\n", sig)
		httpMuxServer.Stop()
	}()
	return httpMuxServer.Start()
}

func formatSocketAddress(addr string) string {
	if !strings.Contains(addr, "://") {
		if strings.Contains(addr, ":") {
			return "tcp://" + addr
		}
		return "unix://" + addr
	}
	return addr
}

func connectAction(c *cli.Context) error {
	if c.NArg() < 1 {
		return fmt.Errorf("missing remote address argument")
	}
	remoteAddr := c.Args().First()
	fmt.Printf("Connecting to remote device at %s\n", remoteAddr)
	return connectToRemote(formatSocketAddress(remoteAddr))
}

func disconnectAction(c *cli.Context) error {
	if c.NArg() < 1 {
		return fmt.Errorf("missing remote address argument")
	}
	remoteAddr := c.Args().First()
	fmt.Printf("Disconnecting from remote device at %s\n", remoteAddr)
	return disconnectFromRemote(formatSocketAddress(remoteAddr))
}

func devicesAction(c *cli.Context) error {
	return listDevices()
}

func killServerAction(c *cli.Context) error {
	fmt.Println("Stopping iosbridge server...")

	// Implement server kill logic
	return killServer()
}