entrypoints.go

package main

import (
	"errors"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
)

func entrypointPath(manager bool) string {
	root := defaultInstallRoot()
	name := silentName
	if manager {
		name = managerName
	}
	switch runtime.GOOS {
	case "darwin":
		return filepath.Join(root, name+".app")
	case "windows":
		return filepath.Join(root, name+".lnk")
	default:
		return filepath.Join(root, name+".desktop")
	}
}

func (s *server) installEntrypoints() commandResult {
	err := installEntrypoints()
	if err != nil {
		return installActionResult("failed", err.Error())
	}
	return installActionResult("ok", "入口已安装。")
}

func (s *server) uninstallEntrypoints(args map[string]any) commandResult {
	options := mapArg(args, "options")
	removeOwnedData := boolArg(options, "removeOwnedData")
	err := uninstallEntrypoints()
	if err == nil && removeOwnedData {
		_ = os.RemoveAll(stateDir())
	}
	if err != nil {
		return installActionResult("failed", err.Error())
	}
	return installActionResult("ok", "入口已卸载。")
}

func (s *server) uninstallCodexTools(args map[string]any) commandResult {
	payload := codexToolsUninstallPayload()
	if runtime.GOOS != "windows" {
		return failed("ChatGPT Codex Tools 卸载功能仅支持 Windows 安装包。", payload)
	}
	options := mapArg(args, "options")
	removeOwnedData := boolArg(options, "removeOwnedData")
	removeWindowsWatcherInstall()
	cleanupWindowsCodexToolsEntrypoints()
	if removeOwnedData {
		_ = os.RemoveAll(stateDir())
	}
	uninstaller := windowsCodexToolsUninstallerPath()
	payload = codexToolsUninstallPayload()
	if uninstaller == "" {
		return ok("未找到 Windows 安装器卸载程序；已移除入口和 watcher。若使用便携版，请手动删除当前 ChatGPT Codex Tools 文件夹。", payload)
	}
	if err := startWindowsCodexToolsUninstaller(uninstaller); err != nil {
		return failed("启动 Windows 卸载程序失败："+err.Error(), payload)
	}
	return ok("已启动 Windows 卸载程序，请按提示完成卸载。", payload)
}

func installActionResult(status, message string) commandResult {
	return commandResult{
		"status":              status,
		"message":             message,
		"silent_shortcut":     shortcutInstallState(entrypointPath(false)),
		"management_shortcut": shortcutInstallState(entrypointPath(true)),
	}
}

func shortcutInstallState(path string) map[string]any {
	return map[string]any{"installed": fileExists(path), "path": path}
}

func installEntrypoints() error {
	switch runtime.GOOS {
	case "darwin":
		if err := writeMacOSAppBundle(false); err != nil {
			return err
		}
		if err := writeMacOSAppBundle(true); err != nil {
			return err
		}
		cleanupLegacyEntrypoints()
		return nil
	case "windows":
		if err := createWindowsShortcut(entrypointPath(false), companionBinaryPath(silentBinary+".exe"), "Launch ChatGPT Codex silently"); err != nil {
			return err
		}
		if err := createWindowsShortcut(entrypointPath(true), companionBinaryPath(managerBinary+".exe"), "Open ChatGPT Codex management tool"); err != nil {
			return err
		}
		cleanupLegacyEntrypoints()
		return nil
	default:
		if err := writeDesktopEntry(false); err != nil {
			return err
		}
		if err := writeDesktopEntry(true); err != nil {
			return err
		}
		cleanupLegacyEntrypoints()
		return nil
	}
}

func uninstallEntrypoints() error {
	var firstErr error
	for _, path := range append([]string{entrypointPath(false), entrypointPath(true)}, legacyEntrypointPaths()...) {
		if err := os.RemoveAll(path); err != nil && firstErr == nil && !errors.Is(err, os.ErrNotExist) {
			firstErr = err
		}
	}
	return firstErr
}

func cleanupLegacyEntrypoints() {
	for _, path := range legacyEntrypointPaths() {
		_ = os.RemoveAll(path)
	}
}

func legacyEntrypointPaths() []string {
	root := defaultInstallRoot()
	switch runtime.GOOS {
	case "darwin":
		return []string{
			filepath.Join(root, "Codex++.app"),
			filepath.Join(root, "Codex++ 管理工具.app"),
			filepath.Join(root, "CodexTools.app"),
		}
	case "windows":
		return []string{
			filepath.Join(root, "Codex++.lnk"),
			filepath.Join(root, "Codex++ 管理工具.lnk"),
			filepath.Join(root, "CodexTools.lnk"),
		}
	default:
		return []string{
			filepath.Join(root, "Codex++.desktop"),
			filepath.Join(root, "Codex++ 管理工具.desktop"),
			filepath.Join(root, "CodexTools.desktop"),
		}
	}
}

const (
	windowsCodexToolsUninstallKey       = `HKCU\Software\Microsoft\Windows\CurrentVersion\Uninstall\ChatGPT Codex Tools`
	legacyWindowsCodexToolsUninstallKey = `HKCU\Software\Microsoft\Windows\CurrentVersion\Uninstall\CodexTools`
)

func codexToolsUninstallPayload() map[string]any {
	uninstaller := windowsCodexToolsUninstallerPath()
	return map[string]any{
		"platform":        runtime.GOOS,
		"supported":       runtime.GOOS == "windows",
		"uninstallerPath": uninstaller,
		"installerFound":  uninstaller != "",
	}
}

func cleanupWindowsCodexToolsEntrypoints() {
	_ = uninstallEntrypoints()
	if runtime.GOOS != "windows" {
		return
	}
	if startMenu := windowsCodexToolsStartMenuDir(); startMenu != "" {
		_ = os.RemoveAll(startMenu)
	}
	if legacyStartMenu := legacyWindowsCodexToolsStartMenuDir(); legacyStartMenu != "" {
		_ = os.RemoveAll(legacyStartMenu)
	}
}

func removeWindowsWatcherInstall() {
	if runtime.GOOS != "windows" {
		return
	}
	_ = windowsRegDeleteCurrentUserValue(watcherRunKey, watcherRunName)
	if shortcut := watcherStartupShortcutPath(); shortcut != "" {
		_ = os.Remove(shortcut)
	}
}

func windowsCodexToolsStartMenuDir() string {
	appdata := os.Getenv("APPDATA")
	if appdata == "" {
		return ""
	}
	return filepath.Join(appdata, "Microsoft", "Windows", "Start Menu", "Programs", "ChatGPT Codex Tools")
}

func legacyWindowsCodexToolsStartMenuDir() string {
	appdata := os.Getenv("APPDATA")
	if appdata == "" {
		return ""
	}
	return filepath.Join(appdata, "Microsoft", "Windows", "Start Menu", "Programs", "CodexTools")
}

func windowsCodexToolsUninstallerPath() string {
	if runtime.GOOS != "windows" {
		return ""
	}
	var candidates []string
	add := func(path string) {
		path = strings.TrimSpace(path)
		if path != "" {
			candidates = append(candidates, path)
		}
	}
	if executable, err := os.Executable(); err == nil {
		add(filepath.Join(filepath.Dir(executable), "Uninstall.exe"))
	}
	if localAppData := os.Getenv("LOCALAPPDATA"); localAppData != "" {
		add(filepath.Join(localAppData, "ChatGPT Codex Tools", "Uninstall.exe"))
		add(filepath.Join(localAppData, "CodexTools", "Uninstall.exe"))
	}
	for _, key := range []string{windowsCodexToolsUninstallKey, legacyWindowsCodexToolsUninstallKey} {
		if installLocation := windowsRegistryString(key, "InstallLocation"); installLocation != "" {
			add(filepath.Join(strings.Trim(installLocation, `"`), "Uninstall.exe"))
		}
		if uninstallString := windowsRegistryString(key, "UninstallString"); uninstallString != "" {
			add(windowsExecutableFromCommand(uninstallString))
		}
	}
	for _, candidate := range candidates {
		if fileExists(candidate) {
			return candidate
		}
	}
	return ""
}

func windowsRegistryString(key, name string) string {
	if runtime.GOOS != "windows" {
		return ""
	}
	cmd := exec.Command("reg", "query", key, "/v", name)
	hideSubprocessWindow(cmd)
	output, err := cmd.Output()
	if err != nil {
		return ""
	}
	return parseWindowsRegQueryValue(string(output), name)
}

func parseWindowsRegQueryValue(output, name string) string {
	for _, line := range strings.Split(output, "\n") {
		trimmed := strings.TrimSpace(line)
		if !strings.HasPrefix(strings.ToLower(trimmed), strings.ToLower(name)) {
			continue
		}
		parts := strings.SplitN(trimmed, "REG_SZ", 2)
		if len(parts) != 2 {
			continue
		}
		return strings.TrimSpace(parts[1])
	}
	return ""
}

func windowsExecutableFromCommand(command string) string {
	trimmed := strings.TrimSpace(command)
	if trimmed == "" {
		return ""
	}
	if strings.HasPrefix(trimmed, `"`) {
		end := strings.Index(trimmed[1:], `"`)
		if end >= 0 {
			return trimmed[1 : end+1]
		}
	}
	fields := strings.Fields(trimmed)
	if len(fields) == 0 {
		return ""
	}
	return fields[0]
}

func startWindowsCodexToolsUninstaller(path string) error {
	if runtime.GOOS != "windows" {
		return errors.New("ChatGPT Codex Tools 卸载程序只支持 Windows")
	}
	cmd := exec.Command(path)
	cmd.Dir = filepath.Dir(path)
	return cmd.Start()
}

func writeMacOSAppBundle(manager bool) error {
	appPath := entrypointPath(manager)
	contents := filepath.Join(appPath, "Contents")
	macos := filepath.Join(contents, "MacOS")
	resources := filepath.Join(contents, "Resources")
	if err := os.MkdirAll(macos, 0o755); err != nil {
		return err
	}
	if err := os.MkdirAll(resources, 0o755); err != nil {
		return err
	}
	displayName := silentName
	executableName := "ChatGPTCodex"
	binary := silentBinary
	identifierSuffix := ""
	if manager {
		displayName = managerName
		executableName = "ChatGPTCodexManager"
		binary = managerBinary
		identifierSuffix = ".manager"
	}
	plist := macOSInfoPlist(displayName, executableName, identifierSuffix)
	if err := os.WriteFile(filepath.Join(contents, "Info.plist"), []byte(plist), 0o644); err != nil {
		return err
	}
	target := companionBinaryPath(binary)
	script := fmt.Sprintf("#!/bin/sh\nexport PATH=\"${PATH:-%s}:%s\"\nexec %q\n", defaultGUIPath, defaultGUIPath, target)
	executable := filepath.Join(macos, executableName)
	if err := os.WriteFile(executable, []byte(script), 0o755); err != nil {
		return err
	}
	_ = copyFirstExistingFile([]string{
		filepath.Join(filepath.Dir(target), "codex-plus-plus.icns"),
		filepath.Join(filepath.Dir(target), "codex-plus-plus.png"),
	}, resources)
	return nil
}

func macOSInfoPlist(displayName, executableName, identifierSuffix string) string {
	return fmt.Sprintf(`<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>CFBundleName</key>
  <string>%s</string>
  <key>CFBundleDisplayName</key>
  <string>%s</string>
  <key>CFBundleIdentifier</key>
	  <string>com.hereww.chatgptcodextools%s</string>
  <key>CFBundleVersion</key>
  <string>%s</string>
  <key>CFBundleShortVersionString</key>
  <string>%s</string>
  <key>CFBundlePackageType</key>
  <string>APPL</string>
  <key>CFBundleExecutable</key>
  <string>%s</string>
  <key>CFBundleIconFile</key>
  <string>codex-plus-plus</string>
  <key>LSUIElement</key>
  <true/>
  <key>LSMinimumSystemVersion</key>
  <string>12.0</string>
</dict>
</plist>`, displayName, displayName, identifierSuffix, version, version, executableName)
}

func copyFirstExistingFile(candidates []string, resources string) error {
	for _, candidate := range candidates {
		data, err := os.ReadFile(candidate)
		if err != nil {
			continue
		}
		return os.WriteFile(filepath.Join(resources, filepath.Base(candidate)), data, 0o644)
	}
	return nil
}

func createWindowsShortcut(shortcutPath, target, description string) error {
	if runtime.GOOS != "windows" {
		return errors.New("Windows shortcuts are only supported on Windows")
	}
	if err := os.MkdirAll(filepath.Dir(shortcutPath), 0o755); err != nil {
		return err
	}
	script := fmt.Sprintf(`$shell = New-Object -ComObject WScript.Shell
$shortcut = $shell.CreateShortcut(%s)
$shortcut.TargetPath = %s
$shortcut.WorkingDirectory = %s
$shortcut.Description = %s
$shortcut.IconLocation = %s
$shortcut.Save()
`, psQuote(shortcutPath), psQuote(target), psQuote(filepath.Dir(target)), psQuote(description), psQuote(target))
	cmd := exec.Command("powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script)
	hideSubprocessWindow(cmd)
	return cmd.Run()
}

func createWindowsShortcutWithArgs(shortcutPath, target, arguments, description string) error {
	if runtime.GOOS != "windows" {
		return errors.New("Windows shortcuts are only supported on Windows")
	}
	if err := os.MkdirAll(filepath.Dir(shortcutPath), 0o755); err != nil {
		return err
	}
	script := fmt.Sprintf(`$shell = New-Object -ComObject WScript.Shell
$shortcut = $shell.CreateShortcut(%s)
$shortcut.TargetPath = %s
$shortcut.Arguments = %s
$shortcut.WorkingDirectory = %s
$shortcut.Description = %s
$shortcut.IconLocation = %s
$shortcut.WindowStyle = 7
$shortcut.Save()
`, psQuote(shortcutPath), psQuote(target), psQuote(arguments), psQuote(filepath.Dir(target)), psQuote(description), psQuote(target))
	cmd := exec.Command("powershell", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script)
	hideSubprocessWindow(cmd)
	return cmd.Run()
}

func windowsRegAddCurrentUserString(key, name, value string) error {
	if runtime.GOOS != "windows" {
		return errors.New("Windows registry is only supported on Windows")
	}
	cmd := exec.Command("reg", "add", key, "/v", name, "/t", "REG_SZ", "/d", value, "/f")
	hideSubprocessWindow(cmd)
	return cmd.Run()
}

func windowsRegDeleteCurrentUserValue(key, name string) error {
	if runtime.GOOS != "windows" {
		return errors.New("Windows registry is only supported on Windows")
	}
	cmd := exec.Command("reg", "delete", key, "/v", name, "/f")
	hideSubprocessWindow(cmd)
	return cmd.Run()
}

func psQuote(value string) string {
	return "'" + strings.ReplaceAll(value, "'", "''") + "'"
}

func writeDesktopEntry(manager bool) error {
	path := entrypointPath(manager)
	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
		return err
	}
	name := silentName
	binary := silentBinary
	if manager {
		name = managerName
		binary = managerBinary
	}
	desktop := fmt.Sprintf("[Desktop Entry]\nType=Application\nName=%s\nExec=%s\nTerminal=false\n", name, companionBinaryPath(binary))
	return os.WriteFile(path, []byte(desktop), 0o755)
}

func watcherPayload() map[string]any {
	flag := filepath.Join(stateDir(), "watcher.disabled")
	install := watcherInstallState()
	runValueInstalled := false
	if runtime.GOOS == "windows" {
		runValueInstalled = strings.TrimSpace(windowsRegistryString(watcherRunKey, watcherRunName)) != ""
	}
	return map[string]any{
		"enabled":                    !fileExists(flag),
		"disabled_flag":              flag,
		"platform":                   runtime.GOOS,
		"install_supported":          runtime.GOOS == "windows",
		"run_value_name":             watcherRunName,
		"run_value":                  install.RunValue,
		"run_value_installed":        runValueInstalled,
		"startup_shortcut":           install.ShortcutPath,
		"startup_shortcut_installed": install.ShortcutPath != "" && fileExists(install.ShortcutPath),
		"launcher_path":              install.LauncherPath,
		"launcher_arguments":         install.Arguments,
	}
}

func watcherInstallState() watcherInstallPlan {
	launcher := companionBinaryPath(silentBinary)
	if runtime.GOOS == "windows" {
		launcher += ".exe"
	}
	return buildWatcherInstallPlan(launcher, defaultWatcherDebugPort, watcherStartupShortcutPath())
}

func buildWatcherInstallPlan(launcherPath string, debugPort int, shortcutPath string) watcherInstallPlan {
	arguments := fmt.Sprintf("--debug-port %d", debugPort)
	return watcherInstallPlan{
		LauncherPath: launcherPath,
		Arguments:    arguments,
		RunValue:     fmt.Sprintf("\"%s\" %s", strings.ReplaceAll(launcherPath, `"`, `\"`), arguments),
		ShortcutPath: shortcutPath,
	}
}

func watcherStartupShortcutPath() string {
	appdata := os.Getenv("APPDATA")
	if appdata == "" {
		return ""
	}
	return filepath.Join(appdata, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", watcherStartupLinkName)
}

func (s *server) installWatcher() commandResult {
	payload := watcherPayload()
	if runtime.GOOS != "windows" {
		return failed("watcher 安装仅支持 Windows；macOS 只能手动从 ChatGPT Codex 入口启动并用启用/禁用控制本地标志。", payload)
	}
	install := watcherInstallState()
	if !fileExists(install.LauncherPath) {
		return failed("安装 watcher 失败：未找到静默启动器 "+install.LauncherPath, watcherPayload())
	}
	if err := windowsRegAddCurrentUserString(watcherRunKey, watcherRunName, install.RunValue); err != nil {
		return failed("安装 watcher 失败："+err.Error(), watcherPayload())
	}
	if install.ShortcutPath != "" {
		_ = os.Remove(install.ShortcutPath)
	}
	spawnWatcherLauncher(install.LauncherPath, defaultWatcherDebugPort)
	return ok("watcher 已安装。", watcherPayload())
}

func (s *server) uninstallWatcher() commandResult {
	if runtime.GOOS != "windows" {
		return ok("watcher 安装仅支持 Windows；当前平台没有需要移除的自动启动项。", watcherPayload())
	}
	if err := windowsRegDeleteCurrentUserValue(watcherRunKey, watcherRunName); err != nil {
		// reg delete returns an error when the value does not exist; removal should remain idempotent.
		_ = err
	}
	if shortcut := watcherStartupShortcutPath(); shortcut != "" {
		_ = os.Remove(shortcut)
	}
	return ok("watcher 已移除。", watcherPayload())
}

func spawnWatcherLauncher(launcherPath string, debugPort int) {
	if runtime.GOOS != "windows" {
		return
	}
	cmd := exec.Command(launcherPath, "--debug-port", strconv.Itoa(debugPort))
	cmd.Stdin = nil
	cmd.Stdout = io.Discard
	cmd.Stderr = io.Discard
	hideSubprocessWindow(cmd)
	_ = cmd.Start()
}

func (s *server) setWatcherDisabled(disabled bool) commandResult {
	flag := filepath.Join(stateDir(), "watcher.disabled")
	if disabled {
		if err := os.MkdirAll(filepath.Dir(flag), 0o755); err != nil {
			return failed("禁用 watcher 失败："+err.Error(), watcherPayload())
		}
		if err := os.WriteFile(flag, []byte("disabled"), 0o644); err != nil {
			return failed("禁用 watcher 失败："+err.Error(), watcherPayload())
		}
		return ok("watcher 已禁用。", watcherPayload())
	}
	if err := os.Remove(flag); err != nil && !errors.Is(err, os.ErrNotExist) {
		return failed("启用 watcher 失败："+err.Error(), watcherPayload())
	}
	return ok("watcher 已启用。", watcherPayload())
}