Go Cursor Help

https://github.com/yuaotian/go-cursor-help
Admin
A tool to reset Cursor IDE's free trial by modifying machine identifiers, supporting Windows, macOS,...
Tokens:7,094
Snippets:28
Trust Score:9.2
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install PowerShell via Winget

Source: https://github.com/yuaotian/go-cursor-help/blob/master/README.md

Installs the Microsoft PowerShell package using the Winget package manager. This command should be run in either Command Prompt or PowerShell.

```powershell
winget install --id Microsoft.PowerShell --source winget
```

--------------------------------

### Run CLI Tool: macOS/Linux, Read-Only, Version

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Demonstrates how to run the `cursor-id-modifier` CLI tool on macOS and Linux. Includes examples for using `sudo` for administrative privileges, enabling read-only protection for the configuration file, and displaying version information. The tool modifies Cursor IDs and handles configuration.

```bash
sudo ./cursor-id-modifier_darwin_x64_intel

./cursor-id-modifier -r

./cursor-id-modifier -v
```

--------------------------------

### Automated Installation Scripts for Cursor ID Modifier

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Cross-platform scripts for one-click automated installation of the Cursor ID modifier. These scripts handle operating system detection, download the appropriate binary, verify integrity, request administrator privileges, execute the modification tool, clean up temporary files, and report status. Supports macOS, Linux, and Windows, with options for accelerated mirrors for users in China.

```bash
# macOS
curl -fsSL https://raw.githubusercontent.com/yuaotian/go-cursor-help/refs/heads/master/scripts/run/cursor_mac_id_modifier.sh -o ./cursor_mac_id_modifier.sh && sudo bash ./cursor_mac_id_modifier.sh && rm ./cursor_mac_id_modifier.sh

# Linux
curl -fsSL https://raw.githubusercontent.com/yuaotian/go-cursor-help/refs/heads/master/scripts/run/cursor_linux_id_modifier.sh | sudo bash

# Windows (PowerShell)
irm https://raw.githubusercontent.com/yuaotian/go-cursor-help/refs/heads/master/scripts/run/cursor_win_id_modifier.ps1 | iex

# China users mirror example (macOS)
curl -fsSL https://aizaozao.com/accelerate.php/https://raw.githubusercontent.com/yuaotian/go-cursor-help/refs/heads/master/scripts/run/cursor_mac_id_modifier.sh -o ./cursor_mac_id_modifier.sh && sudo bash ./cursor_mac_id_modifier.sh && rm ./cursor_mac_id_modifier.sh
```

--------------------------------

### Python Script for Linux Cursor ID Modification

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

A comprehensive Python script designed as a Linux alternative for modifying Cursor application IDs. It requires `sudo` for permissions, finds the Cursor installation, kills running processes, backs up configurations, modifies JavaScript files, and optionally alters the MAC address. The script generates detailed logs and offers an interactive menu for reset options.

```bash
sudo python3 scripts/cursor_id_modifier.py
```

--------------------------------

### Main Application - Full Reset Workflow (Bash)

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

The primary command-line application for orchestrating the complete trial reset process for Cursor. It requires administrator/sudo privileges to run effectively.

```bash
# Basic usage - run with administrator/sudo privileges
# Windows (PowerShell as Administrator)
.\cursor-id-modifier_windows_x64.exe
```

--------------------------------

### Reset Cursor Trial Programmatically in Go

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

This Go code snippet demonstrates how to programmatically reset the Cursor IDE trial period. It initializes necessary components, terminates running Cursor processes, generates new telemetry IDs, preserves the SQM ID if available, and saves the new configuration. It requires the 'logrus', 'go-cursor-help/internal/config', 'go-cursor-help/internal/process', and 'go-cursor-help/pkg/idgen' packages.

```go
package main

import (
    "fmt"
    "log"
    "os"

    "github.com/yuaotian/go-cursor-help/internal/config"
    "github.com/yuaotian/go-cursor-help/internal/process"
    "github.com/yuaotian/go-cursor-help/pkg/idgen"
    "github.com/sirupsen/logrus"
)

func resetCursorTrial(username string, readOnly bool) error {
    logger := logrus.New()
    logger.SetLevel(logrus.InfoLevel)

    // Step 1: Initialize components
    generator := idgen.NewGenerator()
    configManager, err := config.NewManager(username)
    if err != nil {
        return fmt.Errorf("failed to create config manager: %w", err)
    }
    processManager := process.NewManager(nil, logger)

    // Step 2: Kill Cursor processes
    if processManager.IsCursorRunning() {
        logger.Info("Terminating Cursor processes...")
        if err := processManager.KillCursorProcesses(); err != nil {
            return fmt.Errorf("failed to kill processes: %w", err)
        }
    }

    // Step 3: Read existing config (for SQM ID preservation)
    oldConfig, _ := configManager.ReadConfig()

    // Step 4: Generate new configuration
    newConfig := &config.StorageConfig{}
    newConfig.TelemetryMachineId, _ = generator.GenerateMachineID()
    newConfig.TelemetryMacMachineId, _ = generator.GenerateMacMachineID()
    newConfig.TelemetryDevDeviceId, _ = generator.GenerateDeviceID()

    if oldConfig != nil && oldConfig.TelemetrySqmId != "" {
        newConfig.TelemetrySqmId = oldConfig.TelemetrySqmId
    } else {
        newConfig.TelemetrySqmId, _ = generator.GenerateSQMID()
    }

    // Step 5: Save configuration
    if err := configManager.SaveConfig(newConfig, readOnly); err != nil {
        return fmt.Errorf("failed to save config: %w", err)
    }

    logger.Info("Trial reset completed successfully")
    return nil
}

func main() {
    username := os.Getenv("USER")
    if username == "" {
        username = os.Getenv("USERNAME")
    }

    if err := resetCursorTrial(username, true); err != nil {
        log.Fatalf("Error: %v", err)
    }

    fmt.Println("Cursor trial has been reset. Please restart Cursor.")
}

```

--------------------------------

### Generate Machine ID with Auth0 Prefix in Go

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Generates a 64-character hexadecimal machine ID prefixed with 'auth0|user_'. This ID is used for authentication purposes and is validated using a provided function. It relies on the 'github.com/yuaotian/go-cursor-help/pkg/idgen' package.

```go
package main

import (
    "fmt"
    "github.com/yuaotian/go-cursor-help/pkg/idgen"
)

func main() {
    generator := idgen.NewGenerator()

    // Generate a new machine ID
    machineID, err := generator.GenerateMachineID()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    // Output: auth0|user_<64-char-hex>
    // Example: auth0|user_7c6a180b36896a0a8c02787eeafb0e4c6a180b36896a0a8c02787eeafb0e4c
    fmt.Printf("Machine ID: %s\n", machineID)

    // Validate the generated ID
    isValid := generator.ValidateID(machineID, "machineID")
    fmt.Printf("Valid: %v\n", isValid)
}
```

--------------------------------

### SaveConfig - Atomic Configuration Writing in Go

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Safely writes Cursor configuration using atomic operations and includes automatic backup and optional read-only protection. It takes a username and a configuration object, returning an error if the save operation fails.

```go
package main

import (
    "fmt"
    "github.com/yuaotian/go-cursor-help/internal/config"
    "github.com/yuaotian/go-cursor-help/pkg/idgen"
)

func main() {
    username := "john"

    // Initialize config manager
    configManager, err := config.NewManager(username)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    // Read existing config (returns nil if not exists)
    oldConfig, err := configManager.ReadConfig()
    if err != nil {
        fmt.Printf("Error reading config: %v\n", err)
    }

    // Generate new IDs
    generator := idgen.NewGenerator()
    newConfig := &config.StorageConfig{}

    newConfig.TelemetryMachineId, _ = generator.GenerateMachineID()
    newConfig.TelemetryMacMachineId, _ = generator.GenerateMacMachineID()
    newConfig.TelemetryDevDeviceId, _ = generator.GenerateDeviceID()

    // Preserve existing SQM ID or generate new one
    if oldConfig != nil && oldConfig.TelemetrySqmId != "" {
        newConfig.TelemetrySqmId = oldConfig.TelemetrySqmId
    } else {
        newConfig.TelemetrySqmId, _ = generator.GenerateSQMID()
    }

    // Save with read-only protection
    readOnly := true
    err = configManager.SaveConfig(newConfig, readOnly)
    if err != nil {
        fmt.Printf("Save failed: %v\n", err)
        return
    }

    fmt.Println("Configuration saved successfully")
}
```

--------------------------------

### Modify Cursor Machine ID on Linux (China Users)

Source: https://github.com/yuaotian/go-cursor-help/blob/master/README.md

Downloads and executes a script to modify the Cursor machine ID on Linux for users in China. The script is piped directly to bash for execution with sudo privileges. Uses an accelerated URL for download.

```bash
curl -fsSL https://aizaozao.com/accelerate.php/https://raw.githubusercontent.com/yuaotian/go-cursor-help/refs/heads/master/scripts/run/cursor_linux_id_modifier.sh | sudo bash
```

--------------------------------

### Generate UUID Device ID and SQM ID in Go

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Creates a standard UUID v4 formatted device identifier for tracking and telemetry, along with a SQM ID enclosed in curly braces. Both generated IDs are validated using the 'ValidateID' function from the 'github.com/yuaotian/go-cursor-help/pkg/idgen' package.

```go
package main

import (
    "fmt"
    "github.com/yuaotian/go-cursor-help/pkg/idgen"
)

func main() {
    generator := idgen.NewGenerator()

    // Generate device UUID
    deviceID, err := generator.GenerateDeviceID()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    // Output format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
    // Example: 7c6a180b-3689-6a0a-8c02-787eeafb0e4c
    fmt.Printf("Device ID: %s\n", deviceID)

    // Generate SQM ID (with braces)
    sqmID, err := generator.GenerateSQMID()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    // Output: {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}
    fmt.Printf("SQM ID: %s\n", sqmID)

    // Validate
    fmt.Printf("Device ID valid: %v\n", generator.ValidateID(deviceID, "deviceID"))
    fmt.Printf("SQM ID valid: %v\n", generator.ValidateID(sqmID, "sqmID"))
}
```

--------------------------------

### Modify Cursor Machine ID on Windows (China Users)

Source: https://github.com/yuaotian/go-cursor-help/blob/master/README.md

Downloads and executes a script to modify the Cursor machine ID on Windows for users in China. It uses Invoke-WebRequest (irm) to fetch the script and Invoke-Expression (iex) to run it. An accelerated URL is used.

```powershell
irm https://aizaozao.com/accelerate.php/https://raw.githubusercontent.com/yuaotian/go-cursor-help/refs/heads/master/scripts/run/cursor_win_id_modifier.ps1 | iex
```

--------------------------------

### IsCursorRunning - Process Detection in Go

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Checks whether any Cursor processes are currently running on the system. It allows for custom configuration, including retry attempts, delays, and specific process patterns to match.

```go
package main

import (
    "fmt"
    "github.com/yuaotian/go-cursor-help/internal/process"
    "github.com/sirupsen/logrus"
    "time"
)

func main() {
    log := logrus.New()

    // Custom configuration
    config := &process.Config{
        MaxAttempts: 5,
        RetryDelay:  3 * time.Second,
        ProcessPatterns: []string{
            "Cursor.exe",
            "Cursor ",
            "*cursor*",
        },
    }

    processManager := process.NewManager(config, log)

    // Monitor Cursor processes
    for i := 0; i < 10; i++ {
        if processManager.IsCursorRunning() {
            fmt.Printf("[%d] Cursor is running\n", i)
        } else {
            fmt.Printf("[%d] Cursor is not running\n", i)
        }
        time.Sleep(2 * time.Second)
    }
}
```

--------------------------------

### ReadConfig - Configuration Retrieval in Go

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Reads and parses Cursor's storage.json configuration file with proper error handling. It takes a username and returns the configuration object or an error.

```go
package main

import (
    "fmt"
    "github.com/yuaotian/go-cursor-help/internal/config"
)

func main() {
    username := "john"

    configManager, err := config.NewManager(username)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    // Read existing configuration
    config, err := configManager.ReadConfig()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    if config == nil {
        fmt.Println("No existing configuration found")
        return
    }

    // Access configuration fields
    fmt.Println("Existing Configuration:")
    fmt.Printf("  Machine ID: %s\n", config.TelemetryMachineId)
    fmt.Printf("  MAC Machine ID: %s\n", config.TelemetryMacMachineId)
    fmt.Printf("  Device ID: %s\n", config.TelemetryDevDeviceId)
    fmt.Printf("  SQM ID: %s\n", config.TelemetrySqmId)
    fmt.Printf("  Last Modified: %s\n", config.LastModified)
    fmt.Printf("  Version: %s\n", config.Version)
}
```

--------------------------------

### Modify Cursor Machine ID on macOS (China Users)

Source: https://github.com/yuaotian/go-cursor-help/blob/master/README.md

Downloads and executes a script to modify the Cursor machine ID on macOS for users in China. This script is downloaded via an accelerated URL and then executed with sudo privileges. It cleans up the downloaded script afterwards.

```bash
curl -fsSL https://aizaozao.com/accelerate.php/https://raw.githubusercontent.com/yuaotian/go-cursor-help/refs/heads/master/scripts/run/cursor_mac_id_modifier.sh -o ./cursor_mac_id_modifier.sh && sudo bash ./cursor_mac_id_modifier.sh && rm ./cursor_mac_id_modifier.sh
```

--------------------------------

### Generate MAC Address Fingerprint ID in Go

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Produces a 64-character hexadecimal identifier based on the MAC address, suitable for device fingerprinting. This function is part of the 'github.com/yuaotian/go-cursor-help/pkg/idgen' package and can be used to populate telemetry configurations.

```go
package main

import (
    "fmt"
    "github.com/yuaotian/go-cursor-help/pkg/idgen"
)

func main() {
    generator := idgen.NewGenerator()

    macMachineID, err := generator.GenerateMacMachineID()
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    // Output: 64 hex characters
    // Example: a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6a7b8c9d0e1f2
    fmt.Printf("MAC Machine ID: %s\n", macMachineID)
    fmt.Printf("Length: %d\n", len(macMachineID))

    // Use in storage config
    config := map[string]string{
        "telemetry.machineId":    "auth0|user_abc123...",
        "telemetry.macMachineId": macMachineID,
        "telemetry.devDeviceId":  "device-uuid-here",
    }

    for key, value := range config {
        fmt.Printf("%s: %s\n", key, value)
    }
}
```

--------------------------------

### Modify Cursor Machine ID on Linux (Standard)

Source: https://github.com/yuaotian/go-cursor-help/blob/master/README.md

Downloads and executes a script to modify the Cursor machine ID on Linux. The script is piped directly to bash for execution with sudo privileges. This version uses the standard GitHub URL.

```bash
curl -fsSL https://raw.githubusercontent.com/yuaotian/go-cursor-help/refs/heads/master/scripts/run/cursor_linux_id_modifier.sh | sudo bash
```

--------------------------------

### KillCursorProcesses - Safe Process Termination in Go

Source: https://context7.com/yuaotian/go-cursor-help/llms.txt

Terminates all running Cursor processes with graceful shutdown attempts and a forced kill fallback. It utilizes a logger for output and returns an error if termination fails.

```go
package main

import (
    "fmt"
    "github.com/yuaotian/go-cursor-help/internal/process"
    "github.com/sirupsen/logrus"
)

func main() {
    log := logrus.New()
    log.SetLevel(logrus.InfoLevel)

    // Create process manager with default config
    processManager := process.NewManager(nil, log)

    // Check if Cursor is running
    if processManager.IsCursorRunning() {
        fmt.Println("Cursor is running, attempting to close...")

        err := processManager.KillCursorProcesses()
        if err != nil {
            fmt.Printf("Error killing processes: %v\n", err)
            return
        }

        // Verify processes are terminated
        if processManager.IsCursorRunning() {
            fmt.Println("Failed to terminate all Cursor processes")
            return
        }

        fmt.Println("All Cursor processes terminated successfully")
    } else {
        fmt.Println("No Cursor processes running")
    }
}
```

--------------------------------

### Disable Cursor Auto-Update (Linux)

Source: https://github.com/yuaotian/go-cursor-help/blob/master/README.md

This script disables the auto-update feature for Cursor on Linux by removing the update directory and creating a blocking file in its place. Ensure Cursor is closed before executing.

```bash
# Close Cursor
pkill -f "Cursor"
# Remove update directory and create blocking file
rm -rf ~/.config/cursor-updater
touch ~/.config/cursor-updater
```

--------------------------------

### Disable Cursor Auto-Update (macOS)

Source: https://github.com/yuaotian/go-cursor-help/blob/master/README.md

This script disables the auto-update feature for Cursor on macOS by replacing the update configuration file with a read-only blank file. It's noted to be effective for versions 0.45.11 and below. Ensure Cursor is closed before running.

```bash
# NOTE: As tested, this method only works for version 0.45.11 and below.
# Close Cursor
pkill -f "Cursor"
# Replacing app-update.yml with a blank/read-only file
cd /Applications/Cursor.app/Contents/Resources
mv app-update.yml app-update.yml.bak
touch app-update.yml
chmod 444 app-update.yml

# Go to Settings -> Application -> Update, set Mode to none.
# This must be done to prevent Cursor from checking for updates.

# NOTE: The cursor-updater modification method may no longer be effective
# In any case, remove update directory and create blocking file
rm -rf ~/Library/Application\ Support/Caches/cursor-updater
touch ~/Library/Application\ Support/Caches/cursor-updater
```
Tokens:
Raw