Cursor官方的localMode

[leookun]

使用如下脚本可以补丁打开，目前官方的编辑工具实现的比较少，实测只能纯聊

package main

import (
	"bufio"
	"bytes"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"errors"
	"flag"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"regexp"
	"strings"
)

const (
	defaultCursorAppPath  = "/Applications/Cursor.app"
	jsRelativePath        = "Contents/Resources/app/out/vs/workbench/workbench.desktop.main.js"
	agentExecRelativePath = "Contents/Resources/app/extensions/cursor-agent-exec/dist/main.js"
	productRelativePath   = "Contents/Resources/app/product.json"
	checksumKey           = "vs/workbench/workbench.desktop.main.js"
)

var localModePattern = regexp.MustCompile(`(\bcursorPredictionOptions\s*:\s*(?:!1|false)\s*,\s*localMode\s*:\s*)(!1|false)\b`)
var localModeEnabledPattern = regexp.MustCompile(`\blocalMode\s*:\s*(!0|true)\b`)
var checksumPattern = regexp.MustCompile(`("vs/workbench/workbench\.desktop\.main\.js"\s*:\s*")([^"]*)(")`)

const agentExecResponsesNeedle = `return function(e){if(void 0===e)return!1;try{return"api.openai.com"===new URL(e).hostname.toLowerCase()}catch(e){return!1}}(t)&&n.startsWith("gpt-5")||n.includes("codex")?"responses":"chat_completions"`
const agentExecResponsesReplacement = `return n.startsWith("gpt-5")||n.includes("codex")?"responses":"chat_completions"`

type paths struct {
	AppPath             string
	JSPath              string
	ProductPath         string
	BackupPath          string
	AgentExecPath       string
	AgentExecBackupPath string
}

func main() {
	cursorPath := flag.String("path", defaultCursorAppPath, "Cursor.app path or workbench.desktop.main.js path")
	flag.Parse()

	p, err := resolvePaths(*cursorPath)
	if err != nil {
		exitWithError(err)
	}

	reader := bufio.NewReader(os.Stdin)
	for {
		fmt.Println()
		fmt.Println("Cursor localMode patcher")
		fmt.Println("------------------------")
		fmt.Printf("Target JS:      %s\n", p.JSPath)
		fmt.Printf("Agent exec JS:  %s\n", p.AgentExecPath)
		fmt.Printf("Product JSON:   %s\n", p.ProductPath)
		fmt.Printf("Backup file:    %s\n", p.BackupPath)
		fmt.Printf("Agent backup:   %s\n", p.AgentExecBackupPath)
		fmt.Println()
		fmt.Println("1) Enable localMode and GPT-5 responses patch")
		fmt.Println("2) Restore from backups")
		fmt.Println("3) Exit")
		fmt.Print("Choose an option [1-3]: ")

		choice, err := readLine(reader)
		if err != nil {
			if errors.Is(err, io.EOF) {
				fmt.Println()
				return
			}
			exitWithError(err)
		}

		switch strings.TrimSpace(choice) {
		case "1":
			err = enableLocalMode(p)
		case "2":
			err = restoreBackup(p)
		case "3", "q", "quit", "exit":
			fmt.Println("Bye.")
			return
		default:
			fmt.Println("Invalid option.")
			continue
		}

		if err != nil {
			exitWithError(err)
		}
	}
}

func resolvePaths(input string) (paths, error) {
	input = strings.TrimSpace(input)
	if input == "" {
		input = defaultCursorAppPath
	}

	info, err := os.Stat(input)
	if err != nil {
		return paths{}, fmt.Errorf("path not found: %s", input)
	}

	var p paths
	if info.IsDir() && strings.HasSuffix(input, ".app") {
		p.AppPath = input
		p.JSPath = filepath.Join(input, jsRelativePath)
		p.ProductPath = filepath.Join(input, productRelativePath)
		p.AgentExecPath = filepath.Join(input, agentExecRelativePath)
	} else {
		p.JSPath = input
		appPath, err := appPathFromJSPath(input)
		if err != nil {
			return paths{}, err
		}
		p.AppPath = appPath
		p.ProductPath = filepath.Join(appPath, productRelativePath)
		p.AgentExecPath = filepath.Join(appPath, agentExecRelativePath)
	}
	p.BackupPath = p.JSPath + ".back"
	p.AgentExecBackupPath = p.AgentExecPath + ".back"

	if err := requireFile(p.JSPath); err != nil {
		return paths{}, err
	}
	if err := requireFile(p.ProductPath); err != nil {
		return paths{}, err
	}
	if err := requireFile(p.AgentExecPath); err != nil {
		return paths{}, err
	}

	return p, nil
}

func appPathFromJSPath(jsPath string) (string, error) {
	clean := filepath.Clean(jsPath)
	suffix := filepath.Join("Contents", "Resources", "app", "out", "vs", "workbench", "workbench.desktop.main.js")
	if !strings.HasSuffix(clean, suffix) {
		return "", fmt.Errorf("when passing a JS path it must end with %s", suffix)
	}
	appPath := strings.TrimSuffix(clean, suffix)
	appPath = strings.TrimSuffix(appPath, string(os.PathSeparator))
	if !strings.HasSuffix(appPath, ".app") {
		return "", fmt.Errorf("could not infer Cursor.app path from: %s", jsPath)
	}
	return appPath, nil
}

func requireFile(path string) error {
	info, err := os.Stat(path)
	if err != nil {
		return fmt.Errorf("required file not found: %s", path)
	}
	if info.IsDir() {
		return fmt.Errorf("required file is a directory: %s", path)
	}
	return nil
}

func enableLocalMode(p paths) error {
	if err := createBackupIfMissing(p.JSPath, p.BackupPath); err != nil {
		return err
	}
	if err := enableWorkbenchLocalMode(p); err != nil {
		return err
	}
	if err := createBackupIfMissing(p.AgentExecPath, p.AgentExecBackupPath); err != nil {
		return err
	}
	return enableAgentExecResponsesPatch(p)
}

func enableWorkbenchLocalMode(p paths) error {
	content, err := os.ReadFile(p.JSPath)
	if err != nil {
		return err
	}

	if localModeEnabledPattern.Match(content) {
		fmt.Println("[OK] localMode is already enabled.")
		return updateProductChecksum(p)
	}

	if !localModePattern.Match(content) {
		return errors.New("could not find localMode:false or localMode:!1 in workbench.desktop.main.js")
	}

	patched := localModePattern.ReplaceAll(content, []byte("${1}!0"))
	if bytes.Equal(content, patched) {
		return errors.New("patch produced no changes")
	}

	if err := writeFilePreservingMode(p.JSPath, patched); err != nil {
		return err
	}
	fmt.Println("[OK] localMode enabled in workbench.desktop.main.js")

	return updateProductChecksum(p)
}

func restoreBackup(p paths) error {
	workbenchRestored, err := restoreFileFromBackup(p.JSPath, p.BackupPath)
	if err != nil {
		return err
	}
	if !workbenchRestored {
		return fmt.Errorf("backup file does not exist, cannot restore: %s", p.BackupPath)
	}

	fmt.Println("[OK] restored workbench.desktop.main.js from backup")
	if err := updateProductChecksum(p); err != nil {
		return err
	}

	agentRestored, err := restoreFileFromBackup(p.AgentExecPath, p.AgentExecBackupPath)
	if err != nil {
		return err
	}
	if agentRestored {
		fmt.Println("[OK] restored cursor-agent-exec/dist/main.js from backup")
	} else {
		fmt.Printf("[OK] agent exec backup does not exist, skipping: %s\n", p.AgentExecBackupPath)
	}
	return nil
}

func createBackupIfMissing(sourcePath, backupPath string) error {
	if _, err := os.Stat(backupPath); err == nil {
		fmt.Printf("[OK] backup already exists, keeping it unchanged: %s\n", backupPath)
		return nil
	} else if !errors.Is(err, os.ErrNotExist) {
		return err
	}

	src, err := os.Open(sourcePath)
	if err != nil {
		return err
	}
	defer src.Close()

	info, err := src.Stat()
	if err != nil {
		return err
	}

	dst, err := os.OpenFile(backupPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, info.Mode())
	if err != nil {
		return err
	}

	_, copyErr := io.Copy(dst, src)
	closeErr := dst.Close()
	if copyErr != nil {
		_ = os.Remove(backupPath)
		return copyErr
	}
	if closeErr != nil {
		_ = os.Remove(backupPath)
		return closeErr
	}

	fmt.Printf("[OK] backup created: %s\n", backupPath)
	return nil
}

func restoreFileFromBackup(targetPath, backupPath string) (bool, error) {
	if _, err := os.Stat(backupPath); err != nil {
		if errors.Is(err, os.ErrNotExist) {
			return false, nil
		}
		return false, err
	}

	backup, err := os.ReadFile(backupPath)
	if err != nil {
		return false, err
	}
	if err := writeFilePreservingMode(targetPath, backup); err != nil {
		return false, err
	}
	return true, nil
}

func enableAgentExecResponsesPatch(p paths) error {
	content, err := os.ReadFile(p.AgentExecPath)
	if err != nil {
		return err
	}

	if bytes.Contains(content, []byte(agentExecResponsesReplacement)) {
		fmt.Println("[OK] GPT-5 responses patch is already enabled in cursor-agent-exec/dist/main.js")
		return nil
	}

	count := bytes.Count(content, []byte(agentExecResponsesNeedle))
	if count != 1 {
		return fmt.Errorf("expected exactly one GPT-5 responses patch target in cursor-agent-exec/dist/main.js, found %d", count)
	}

	patched := bytes.Replace(content, []byte(agentExecResponsesNeedle), []byte(agentExecResponsesReplacement), 1)
	if bytes.Equal(content, patched) {
		return errors.New("agent exec patch produced no changes")
	}
	if err := writeFilePreservingMode(p.AgentExecPath, patched); err != nil {
		return err
	}
	fmt.Println("[OK] GPT-5 responses patch enabled in cursor-agent-exec/dist/main.js")
	return nil
}

func updateProductChecksum(p paths) error {
	jsContent, err := os.ReadFile(p.JSPath)
	if err != nil {
		return err
	}
	sum := sha256.Sum256(jsContent)
	checksum := strings.TrimRight(base64.StdEncoding.EncodeToString(sum[:]), "=")

	productContent, err := os.ReadFile(p.ProductPath)
	if err != nil {
		return err
	}

	var product map[string]any
	if err := json.Unmarshal(productContent, &product); err != nil {
		return err
	}

	checksumsAny, ok := product["checksums"]
	if !ok {
		return errors.New("product.json does not contain checksums")
	}
	checksums, ok := checksumsAny.(map[string]any)
	if !ok {
		return errors.New("product.json checksums field is not an object")
	}

	old, _ := checksums[checksumKey].(string)
	checksums[checksumKey] = checksum

	if !checksumPattern.Match(productContent) {
		return fmt.Errorf("could not find %q in product.json checksums", checksumKey)
	}
	updated := checksumPattern.ReplaceAll(productContent, []byte("${1}"+checksum+"${3}"))

	if err := writeFilePreservingMode(p.ProductPath, updated); err != nil {
		return err
	}

	fmt.Printf("[OK] checksum updated: %s -> %s\n", old, checksum)
	return nil
}

func writeFilePreservingMode(path string, content []byte) error {
	info, err := os.Stat(path)
	if err != nil {
		return err
	}
	return os.WriteFile(path, content, info.Mode())
}

func readLine(reader *bufio.Reader) (string, error) {
	line, err := reader.ReadString('\n')
	if errors.Is(err, io.EOF) {
		if line == "" {
			return "", io.EOF
		}
		return line, nil
	}
	return line, err
}

func exitWithError(err error) {
	fmt.Fprintf(os.Stderr, "[ERROR] %v\n", err)
	os.Exit(1)
}

[1723582046]

这个是做什么的🤓

[leookun]

这是cursor官方内置的localMode，目前官方应该还在开发中，不是生产可用的级别

[feely0208]

QQ群满了，有新的吗，有问题请教

[leookun]

https://t.me/cursor_byok