package main

import (

"context"

"fmt"

"os"

"os/signal"

"runtime"

"syscall"

"github.com/fosrl/newt/logger"

"github.com/fosrl/newt/updates"

olmpkg "github.com/fosrl/olm/olm"

)

var olmVersion = "version_replaceme"

func main() {

// Check if we're running as a Windows service

if isWindowsService() {

runService("OlmWireguardService", false, os.Args[1:])

fmt.Println("Running as Windows service")

return

}

// Handle service management commands on Windows

if runtime.GOOS == "windows" {

var command string

if len(os.Args) > 1 {

command = os.Args[1]

} else {

command = "default"

}

switch command {

case "install":

err := installService()

if err != nil {

fmt.Printf("Failed to install service: %v\n", err)

os.Exit(1)

}

fmt.Println("Service installed successfully")

return

case "remove", "uninstall":

err := removeService()

if err != nil {

fmt.Printf("Failed to remove service: %v\n", err)

os.Exit(1)

}

fmt.Println("Service removed successfully")

return

case "start":

// Pass the remaining arguments (after "start") to the service

serviceArgs := os.Args[2:]

err := startService(serviceArgs)

if err != nil {

fmt.Printf("Failed to start service: %v\n", err)

os.Exit(1)

}

fmt.Println("Service started successfully")

return

case "stop":

err := stopService()

if err != nil {

fmt.Printf("Failed to stop service: %v\n", err)

os.Exit(1)

}

fmt.Println("Service stopped successfully")

return

case "status":

status, err := getServiceStatus()

if err != nil {

fmt.Printf("Failed to get service status: %v\n", err)

os.Exit(1)

}

fmt.Printf("Service status: %s\n", status)

return

case "debug":

// get the status and if it is Not Installed then install it first

status, err := getServiceStatus()

if err != nil {

fmt.Printf("Failed to get service status: %v\n", err)

os.Exit(1)

}

if status == "Not Installed" {

err := installService()

if err != nil {

fmt.Printf("Failed to install service: %v\n", err)

os.Exit(1)

}

fmt.Println("Service installed successfully, now running in debug mode")

}

// Pass the remaining arguments (after "debug") to the service

serviceArgs := os.Args[2:]

err = debugService(serviceArgs)

if err != nil {

fmt.Printf("Failed to debug service: %v\n", err)

os.Exit(1)

}

return

case "logs":

err := watchLogFile(false)

if err != nil {

fmt.Printf("Failed to watch log file: %v\n", err)

os.Exit(1)

}

return

case "config":

if runtime.GOOS == "windows" {

showServiceConfig()

} else {

fmt.Println("Service configuration is only available on Windows")

}

return

case "help", "--help", "-h":

fmt.Println("Olm WireGuard VPN Client")

fmt.Println("\nWindows Service Management:")

fmt.Println(" install Install the service")

fmt.Println(" remove Remove the service")

fmt.Println(" start [args] Start the service with optional arguments")

fmt.Println(" stop Stop the service")

fmt.Println(" status Show service status")

fmt.Println(" debug [args] Run service in debug mode with optional arguments")

fmt.Println(" logs Tail the service log file")

fmt.Println(" config Show current service configuration")

fmt.Println("\nExamples:")

fmt.Println(" olm start --enable-http --http-addr :9452")

fmt.Println(" olm debug --endpoint https://example.com --id myid --secret mysecret")

fmt.Println("\nFor console mode, run without arguments or with standard flags.")

return

default:

// get the status and if it is Not Installed then install it first

status, err := getServiceStatus()

if err != nil {

fmt.Printf("Failed to get service status: %v\n", err)

os.Exit(1)

}

if status == "Not Installed" {

err := installService()

if err != nil {

fmt.Printf("Failed to install service: %v\n", err)

os.Exit(1)

}

fmt.Println("Service installed successfully, now running")

}

// Pass the remaining arguments (after "debug") to the service

serviceArgs := os.Args[1:]

err = debugService(serviceArgs)

if err != nil {

fmt.Printf("Failed to debug service: %v\n", err)

os.Exit(1)

}

return

}

}

// Create a context that will be cancelled on interrupt signals

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

defer stop()

// Create a separate context for programmatic shutdown (e.g., via API exit)

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

defer cancel()

// Run in console mode

runOlmMainWithArgs(ctx, cancel, signalCtx, os.Args[1:])

}

func runOlmMainWithArgs(ctx context.Context, cancel context.CancelFunc, signalCtx context.Context, args []string) {

// Setup Windows event logging if on Windows

if runtime.GOOS == "windows" {

setupWindowsEventLog()

} else {

// Initialize logger for non-Windows platforms

logger.Init(nil)

}

// Load configuration from file, env vars, and CLI args

// Priority: CLI args > Env vars > Config file > Defaults

// Use the passed args parameter instead of os.Args[1:] to support Windows service mode

config, showVersion, showConfig, err := LoadConfig(args)

if err != nil {

fmt.Printf("Failed to load configuration: %v\n", err)

return

}

// Handle --show-config flag

if showConfig {

config.ShowConfig()

os.Exit(0)

}

if showVersion {

fmt.Println("Olm version " + olmVersion)

os.Exit(0)

}

logger.Info("Olm version %s", olmVersion)

config.Version = olmVersion

if err := SaveConfig(config); err != nil {

logger.Error("Failed to save full olm config: %v", err)

} else {

logger.Debug("Saved full olm config with all options")

}

if err := updates.CheckForUpdate("fosrl", "olm", config.Version); err != nil {

logger.Debug("Failed to check for updates: %v", err)

}

// Create a new olm.Config struct and copy values from the main config

olmConfig := olmpkg.OlmConfig{

LogLevel: config.LogLevel,

EnableAPI: config.EnableAPI,

HTTPAddr: config.HTTPAddr,

SocketPath: config.SocketPath,

Version: config.Version,

Agent: "Olm CLI",

OnExit: cancel, // Pass cancel function directly to trigger shutdown

OnTerminated: cancel,

PprofAddr: ":4444", // TODO: REMOVE OR MAKE CONFIGURABLE

}

olm, err := olmpkg.Init(ctx, olmConfig)

if err != nil {

logger.Fatal("Failed to initialize olm: %v", err)

}

if err := olm.StartApi(); err != nil {

logger.Fatal("Failed to start API server: %v", err)

}

if config.ID != "" && config.Secret != "" && config.Endpoint != "" {

tunnelConfig := olmpkg.TunnelConfig{

Endpoint: config.Endpoint,

ID: config.ID,

Secret: config.Secret,

UserToken: config.UserToken,

MTU: config.MTU,

DNS: config.DNS,

UpstreamDNS: config.UpstreamDNS,

InterfaceName: config.InterfaceName,

Holepunch: !config.DisableHolepunch,

TlsClientCert: config.TlsClientCert,

PingIntervalDuration: config.PingIntervalDuration,

PingTimeoutDuration: config.PingTimeoutDuration,

OrgID: config.OrgID,

OverrideDNS: config.OverrideDNS,

DisableRelay: config.DisableRelay,

EnableUAPI: true,

}

go olm.StartTunnel(tunnelConfig)

} else {

logger.Info("Incomplete tunnel configuration, not starting tunnel")

}

// Wait for either signal or programmatic shutdown

select {

case <-signalCtx.Done():

logger.Info("Shutdown signal received, cleaning up...")

case <-ctx.Done():

logger.Info("Shutdown requested via API, cleaning up...")

}

// Clean up resources

olm.Close()

logger.Info("Shutdown complete")

}