Update main.go

main.go

@@ -10,6 +10,7 @@ import (
 	"net/http"
 	"net/url"
 	"os"
+	"regexp"
 	"strings"
 	"time"
 
@@ -368,66 +369,204 @@ func requestToken() (string, error) {
 }
 
 func requestTokenAndHash() (string, string, error) {
-	req, err := http.NewRequest("GET", "https://duckduckgo.com/duckchat/v1/status", nil)
+	// Create a client with proper settings
+	client := createHTTPClient(30 * time.Second)
+	
+	// First, visit the DuckDuckGo main page
+	req, err := http.NewRequest("GET", "https://duckduckgo.com/", nil)
 	if err != nil {
-		return "", "", fmt.Errorf("创建请求失败: %v", err)
+		return "", "", fmt.Errorf("failed to create homepage request: %v", err)
 	}
+	
 	for k, v := range config.FakeHeaders {
 		req.Header.Set(k, v)
 	}
-	req.Header.Set("x-vqd-accept", "1")
-
-	client := createHTTPClient(10 * time.Second)
-
-	log.Println("发送 token 请求")
+	
+	log.Println("Sending request to DuckDuckGo homepage")
 	resp, err := client.Do(req)
 	if err != nil {
-		return "", "", fmt.Errorf("请求失败: %v", err)
+		return "", "", fmt.Errorf("homepage request failed: %v", err)
 	}
 	defer resp.Body.Close()
-
+	
 	if resp.StatusCode != http.StatusOK {
 		bodyBytes, _ := io.ReadAll(resp.Body)
-		bodyString := string(bodyBytes)
-		log.Printf("requestToken: 非200响应: %d, 内容: %s\n", resp.StatusCode, bodyString)
-		return "", "", fmt.Errorf("非200响应: %d, 内容: %s", resp.StatusCode, bodyString)
+		return "", "", fmt.Errorf("homepage request returned status %d: %s", resp.StatusCode, string(bodyBytes))
 	}
-
-	// 从响应头中获取令牌
-	token := resp.Header.Get("x-vqd-4")
-	if token == "" {
-		return "", "", errors.New("响应中未包含x-vqd-4头")
+	
+	// Read homepage content to extract vqd-related JavaScript
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to read homepage: %v", err)
 	}
-
-	// 从响应头中获取x-vqd-hash-1
-	vqdHash := resp.Header.Get("x-vqd-hash-1")
-	if vqdHash == "" {
-		// 尝试从响应体中获取
-		bodyBytes, err := io.ReadAll(resp.Body)
+	
+	bodyStr := string(bodyBytes)
+	
+	// Method 1: Try to extract the vqd directly from the HTML attributes
+	// DuckDuckGo often embeds this in data attributes or JavaScript variables
+	vqdRegex := regexp.MustCompile(`vqd=["']([^"']+)["']`)
+	matches := vqdRegex.FindStringSubmatch(bodyStr)
+	
+	if len(matches) < 2 {
+		// Try alternate regex patterns if the first one didn't match
+		alternatePatterns := []string{
+			`vqd[:=]["']([^"']+)["']`,
+			`"vqd":"([^"]+)"`,
+			`'vqd':'([^']+)'`,
+		}
+		
+		for _, pattern := range alternatePatterns {
+			r := regexp.MustCompile(pattern)
+			matches = r.FindStringSubmatch(bodyStr)
+			if len(matches) >= 2 {
+				break
+			}
+		}
+	}
+	
+	if len(matches) >= 2 {
+		token := matches[1]
+		log.Printf("Successfully extracted vqd token: %s", token)
+		return token, "", nil
+	}
+	
+	// Method 2: Get the JavaScript file that contains the token generation logic
+	jsURLRegex := regexp.MustCompile(`(\/dist\/[^"']+\.js)`)
+	jsMatches := jsURLRegex.FindAllStringSubmatch(bodyStr, -1)
+	
+	for _, match := range jsMatches {
+		if len(match) < 2 {
+			continue
+		}
+		
+		jsURL := "https://duckduckgo.com" + match[1]
+		log.Printf("Trying to get vqd from JavaScript file: %s", jsURL)
+		
+		jsReq, err := http.NewRequest("GET", jsURL, nil)
 		if err != nil {
-			log.Printf("读取响应体失败: %v", err)
-		} else {
-			// 记录响应体以便调试
-			log.Printf("响应体: %s", string(bodyBytes))
-			
-			// 尝试从JSON响应中解析可能包含的哈希值
-			var respObj map[string]interface{}
-			if err := json.Unmarshal(bodyBytes, &respObj); err == nil {
-				if hashValue, ok := respObj["x-vqd-hash-1"].(string); ok {
-					vqdHash = hashValue
-				}
+			log.Printf("Failed to create request for JS file: %v", err)
+			continue
+		}
+		
+		for k, v := range config.FakeHeaders {
+			jsReq.Header.Set(k, v)
+		}
+		
+		jsResp, err := client.Do(jsReq)
+		if err != nil {
+			log.Printf("Failed to get JS file: %v", err)
+			continue
+		}
+		
+		jsBytes, err := io.ReadAll(jsResp.Body)
+		jsResp.Body.Close()
+		
+		if err != nil {
+			log.Printf("Failed to read JS file: %v", err)
+			continue
+		}
+		
+		jsContent := string(jsBytes)
+		
+		// Look for vqd token patterns in the JS file
+		vqdInJSRegex := regexp.MustCompile(`vqd\s*[:=]\s*["']([^"']+)["']`)
+		jsMatches := vqdInJSRegex.FindStringSubmatch(jsContent)
+		
+		if len(jsMatches) >= 2 {
+			token := jsMatches[1]
+			log.Printf("Found vqd token in JS file: %s", token)
+			return token, "", nil
+		}
+		
+		// Try another pattern specific to the format in the JS file
+		vqdInJSRegex2 := regexp.MustCompile(`"vqd"\s*:\s*"([^"]+)"`)
+		jsMatches2 := vqdInJSRegex2.FindStringSubmatch(jsContent)
+		
+		if len(jsMatches2) >= 2 {
+			token := jsMatches2[1]
+			log.Printf("Found vqd token in JS file (pattern 2): %s", token)
+			return token, "", nil
+		}
+	}
+	
+	// Method 3 (Fallback): Try to request duck.js or related files which might contain the token
+	fallbackURLs := []string{
+		"https://duckduckgo.com/duck.js",
+		"https://duckduckgo.com/chat.js",
+		"https://duckduckgo.com/d.js",
+	}
+	
+	for _, url := range fallbackURLs {
+		fallbackReq, err := http.NewRequest("GET", url, nil)
+		if err != nil {
+			log.Printf("Failed to create request for fallback URL %s: %v", url, err)
+			continue
+		}
+		
+		for k, v := range config.FakeHeaders {
+			fallbackReq.Header.Set(k, v)
+		}
+		
+		fallbackResp, err := client.Do(fallbackReq)
+		if err != nil {
+			log.Printf("Failed to get fallback URL %s: %v", url, err)
+			continue
+		}
+		
+		fallbackBytes, err := io.ReadAll(fallbackResp.Body)
+		fallbackResp.Body.Close()
+		
+		if err != nil {
+			log.Printf("Failed to read fallback URL %s: %v", url, err)
+			continue
+		}
+		
+		fallbackContent := string(fallbackBytes)
+		
+		// Try multiple regex patterns to find the vqd token
+		patterns := []string{
+			`vqd\s*[:=]\s*["']([^"']+)["']`,
+			`"vqd"\s*:\s*"([^"]+)"`,
+			`'vqd'\s*:\s*'([^']+)'`,
+		}
+		
+		for _, pattern := range patterns {
+			r := regexp.MustCompile(pattern)
+			m := r.FindStringSubmatch(fallbackContent)
+			if len(m) >= 2 {
+				token := m[1]
+				log.Printf("Found vqd token in fallback URL %s: %s", url, token)
+				return token, "", nil
 			}
 		}
 	}
 	
-	log.Printf("获取到的 token: %s", token)
-	if vqdHash != "" {
-		log.Printf("获取到的 hash: %s", vqdHash)
-	} else {
-		log.Println("未获取到 hash 值")
+	// Last resort: try the duckchat/v1/status endpoint which we know returns the token in headers
+	statusReq, err := http.NewRequest("GET", "https://duckduckgo.com/duckchat/v1/status", nil)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to create status request: %v", err)
+	}
+	
+	for k, v := range config.FakeHeaders {
+		statusReq.Header.Set(k, v)
+	}
+	statusReq.Header.Set("x-vqd-accept", "1")
+	
+	log.Println("Trying duckchat/v1/status as last resort")
+	statusResp, err := client.Do(statusReq)
+	if err != nil {
+		return "", "", fmt.Errorf("status request failed: %v", err)
+	}
+	defer statusResp.Body.Close()
+	
+	// Check X-VQD-4 header
+	token := statusResp.Header.Get("x-vqd-4")
+	if token != "" {
+		log.Printf("Found vqd token in status response header: %s", token)
+		return token, "", nil
 	}
 	
-	return token, vqdHash, nil
+	return "", "", errors.New("could not find vqd token using any method")
 }
 
 func prepareMessages(messages []struct {
@@ -532,4 +671,4 @@ func createHTTPClient(timeout time.Duration) *http.Client {
 	}
 	
 	return client
-}
+}