feat: service auto installation

Author: kermanx

sdk/go/lib.go

@@ -35,19 +35,16 @@ type serviceInfo struct {
 	URL string `json:"url"`
 }
 
-// appRegisterRequest represents the request body for app registration
 type appRegisterRequest struct {
 	Name        string `json:"name"`
 	Description string `json:"description"`
 	UID         string `json:"uid,omitempty"`
 }
 
-// appRegisterResponse represents the response from app registration
 type appRegisterResponse struct {
 	Token string `json:"token"`
 }
 
-// uniTokenDetectionResponse represents the response for service detection
 type uniTokenDetectionResponse struct {
 	UniToken bool `json:"__uni_token"`
 }
@@ -188,18 +185,18 @@ func downloadService(execPath string) error {
 }
 
 // RequestUniTokenOpenAI requests user for OpenAI token via UniToken service
-// Returns the baseURL and apiKey, or nil if the user does not grant permission
-func RequestUniTokenOpenAI(options UniTokenOptions) (*UniTokenResult, error) {
+// Returns the baseURL and apiKey. apiKey is empty if the user does not grant permission
+func RequestUniTokenOpenAI(options UniTokenOptions) (UniTokenResult, error) {
 	rootPath, err := setupServiceRootPath()
 	if err != nil {
-		return nil, fmt.Errorf("failed to setup service root path: %w", err)
+		return UniTokenResult{}, fmt.Errorf("failed to setup service root path: %w", err)
 	}
 	serverURL, err := detectRunningURLFromFile(rootPath)
 
 	if err != nil || serverURL == "" {
 		serverURL, err = startService(rootPath)
 		if err != nil {
-			return nil, fmt.Errorf("failed to start service: %w", err)
+			return UniTokenResult{}, fmt.Errorf("failed to start service: %w", err)
 		}
 	}
 
@@ -211,7 +208,7 @@ func RequestUniTokenOpenAI(options UniTokenOptions) (*UniTokenResult, error) {
 
 	jsonData, err := json.Marshal(requestBody)
 	if err != nil {
-		return nil, fmt.Errorf("failed to marshal request: %w", err)
+		return UniTokenResult{}, fmt.Errorf("failed to marshal request: %w", err)
 	}
 
 	client := &http.Client{Timeout: 30 * time.Second}
@@ -221,28 +218,28 @@ func RequestUniTokenOpenAI(options UniTokenOptions) (*UniTokenResult, error) {
 		bytes.NewBuffer(jsonData),
 	)
 	if err != nil {
-		return nil, fmt.Errorf("registration request failed: %w", err)
+		return UniTokenResult{}, fmt.Errorf("registration request failed: %w", err)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode == http.StatusForbidden {
-		return &UniTokenResult{
+		return UniTokenResult{
 			BaseURL: fmt.Sprintf("%sopenai/", serverURL),
 			APIKey:  "",
 		}, nil // User denied permission
 	}
 
 	if resp.StatusCode != http.StatusOK {
 		body, _ := io.ReadAll(resp.Body)
-		return nil, fmt.Errorf("registration failed: HTTP %d - %s", resp.StatusCode, string(body))
+		return UniTokenResult{}, fmt.Errorf("registration failed: HTTP %d - %s", resp.StatusCode, string(body))
 	}
 
 	var registerResp appRegisterResponse
 	if err := json.NewDecoder(resp.Body).Decode(&registerResp); err != nil {
-		return nil, fmt.Errorf("failed to decode response: %w", err)
+		return UniTokenResult{}, fmt.Errorf("failed to decode response: %w", err)
 	}
 
-	return &UniTokenResult{
+	return UniTokenResult{
 		BaseURL: fmt.Sprintf("%sopenai/", serverURL),
 		APIKey:  registerResp.Token,
 	}, nil

service/discovery/data.go

@@ -7,27 +7,26 @@ import (
 	"time"
 )
 
-type ServiceData struct {
+type ServiceInfo struct {
 	Command   []string `json:"command"`
 	PID       int      `json:"pid"`
-	URL       *string  `json:"url"`
+	URL       string   `json:"url"`
 	Timestamp int64    `json:"timestamp"`
 }
 
-func GetData(port *int) string {
-	var url *string
+func GetServiceInfo(port *int) string {
+	var url string
 	if port != nil {
-		urlStr := fmt.Sprintf("http://localhost:%d/", *port)
-		url = &urlStr
+		url = fmt.Sprintf("http://localhost:%d/", *port)
 	}
 
-	data := ServiceData{
+	service := ServiceInfo{
 		Command:   os.Args,
 		PID:       os.Getpid(),
 		URL:       url,
 		Timestamp: time.Now().UnixMilli(),
 	}
 
-	jsonData, _ := json.MarshalIndent(data, "", "  ")
+	jsonData, _ := json.MarshalIndent(service, "", "  ")
 	return string(jsonData)
 }

service/discovery/file.go

@@ -9,25 +9,38 @@ import (
 	"syscall"
 )
 
-func getFilePath() string {
+func getServiceRootPath() string {
 	if runtime.GOOS == "windows" {
 		localAppData := os.Getenv("LOCALAPPDATA")
-		return filepath.Join(localAppData, "UniToken", "service.json")
+		return filepath.Join(localAppData, "UniToken")
+	} else {
+		home := os.Getenv("HOME")
+		return filepath.Join(home, ".local", "share", "uni-token")
 	}
-	home := os.Getenv("HOME")
-	return filepath.Join(home, ".local", "share", "uni-token", "service.json")
+}
+
+func GetServiceExecutablePath() string {
+	if runtime.GOOS == "windows" {
+		return filepath.Join(getServiceRootPath(), "service.exe")
+	} else {
+		return filepath.Join(getServiceRootPath(), "service")
+	}
+}
+
+func getServiceJsonPath() string {
+	return filepath.Join(getServiceRootPath(), "service.json")
 }
 
 func SetupFileDiscovery(port int) error {
-	filePath := getFilePath()
+	filePath := getServiceJsonPath()
 
 	// Create directory if it doesn't exist
 	if err := os.MkdirAll(filepath.Dir(filePath), 0755); err != nil {
 		return err
 	}
 
 	// Write initial service data
-	if err := os.WriteFile(filePath, []byte(GetData(&port)), 0644); err != nil {
+	if err := os.WriteFile(filePath, []byte(GetServiceInfo(&port)), 0644); err != nil {
 		return err
 	}
 
@@ -40,7 +53,7 @@ func SetupFileDiscovery(port int) error {
 	go func() {
 		<-c
 		// Write final service data with null port on exit
-		os.WriteFile(filePath, []byte(GetData(nil)), 0644)
+		os.WriteFile(filePath, []byte(GetServiceInfo(nil)), 0644)
 		os.Exit(0)
 	}()
 

service/discovery/install.go

@@ -0,0 +1,66 @@
+package discovery
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+)
+
+func InstallExecutable() error {
+	targetPath := GetServiceExecutablePath()
+	selfPath := os.Args[0]
+	if runtime.GOOS != "windows" {
+		var err error
+		selfPath, err = os.Executable()
+		if err != nil {
+			return err
+		}
+	}
+
+	if targetPath == selfPath {
+		return nil
+	}
+
+	if _, err := os.Stat(targetPath); os.IsNotExist(err) {
+		if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+			return err
+		}
+		if err := copyFile(selfPath, targetPath); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func copyFile(src, dst string) error {
+	sourceFile, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer sourceFile.Close()
+
+	destinationFile, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	defer destinationFile.Close()
+
+	_, err = io.Copy(destinationFile, sourceFile)
+	if err != nil {
+		return err
+	}
+
+	err = destinationFile.Sync()
+	if err != nil {
+		return err
+	}
+
+	err = os.Chmod(dst, 0755)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

service/discovery/named_pipe.go

@@ -0,0 +1,49 @@
+package discovery
+
+import (
+	"encoding/json"
+	"net/http"
+	"os"
+	"time"
+)
+
+type uniTokenDetectionResponse struct {
+	UniToken bool `json:"__uni_token"`
+}
+
+func IsServiceRunning() bool {
+	filePath := getServiceJsonPath()
+
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		return false
+	}
+
+	fileContent, err := os.ReadFile(filePath)
+	if err != nil {
+		return false
+	}
+
+	var info ServiceInfo
+	if err := json.Unmarshal(fileContent, &info); err != nil {
+		return false
+	}
+
+	if info.URL == "" {
+		return false
+	}
+
+	// Verify the service is actually running
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Get(info.URL)
+	if err != nil {
+		return false
+	}
+	defer resp.Body.Close()
+
+	var detection uniTokenDetectionResponse
+	if err := json.NewDecoder(resp.Body).Decode(&detection); err != nil {
+		return false
+	}
+
+	return detection.UniToken
+}

service/discovery/singleton.go

@@ -33,12 +33,6 @@ func registerURLSchemeLinux(options UrlSchemeRegisterOption) error {
 	desktopFileName := fmt.Sprintf("%s.desktop", options.AppName)
 	desktopFilePath := filepath.Join(desktopDir, desktopFileName)
 
-	// Get current executable path
-	exePath, err := os.Executable()
-	if err != nil {
-		return fmt.Errorf("failed to get executable path: %w", err)
-	}
-
 	// Write .desktop file content
 	content := fmt.Sprintf(`[Desktop Entry]
 Name=%s
@@ -47,7 +41,7 @@ Exec=%s url %%u
 Terminal=false
 Type=Application
 MimeType=x-scheme-handler/%s;
-`, options.AppName, options.Scheme, exePath, options.Scheme)
+`, options.AppName, options.Scheme, options.ExecutablePath, options.Scheme)
 
 	if err := os.WriteFile(desktopFilePath, []byte(content), 0644); err != nil {
 		return fmt.Errorf("failed to write .desktop file: %w", err)

service/logic/url_scheme/linux.go

@@ -6,8 +6,9 @@ import (
 )
 
 type UrlSchemeRegisterOption struct {
-	Scheme  string
-	AppName string
+	Scheme         string
+	AppName        string
+	ExecutablePath string
 }
 
 func RegisterURLScheme(options UrlSchemeRegisterOption) error {