From c3a14c8eef05acf8b6a7660db64d373d1d853876 Mon Sep 17 00:00:00 2001
From: emotion04 <1695617871@qq.com>
Date: Mon, 20 Jul 2026 14:28:17 +0800
Subject: [PATCH 1/2] =?UTF-8?q?feat:=20add=20bing-cli=20=E2=80=94=20Bing?=
 =?UTF-8?q?=20search=20CLI=20powered=20by=20browser=20automation?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: Claude <noreply@anthropic.com>
---
 bing-cli/.gitignore                           |  15 ++
 bing-cli/.gitignore.baiduyun.uploading.cfg    | Bin 0 -> 679 bytes
 bing-cli/ARCHAEOLOGY.md                       |  97 +++++++++
 bing-cli/README.md                            | 103 +++++++++
 bing-cli/bing/common.go                       |  41 ++++
 .../bing/common.go.baiduyun.uploading.cfg     | Bin 0 -> 685 bytes
 bing-cli/bing/result.go                       |  73 +++++++
 .../bing/result.go.baiduyun.uploading.cfg     | Bin 0 -> 684 bytes
 bing-cli/bing/search.go                       | 206 ++++++++++++++++++
 bing-cli/browser/client.go                    | 120 ++++++++++
 bing-cli/cmd/root.go                          | 178 +++++++++++++++
 bing-cli/go.mod                               |   9 +
 bing-cli/go.sum                               |  10 +
 bing-cli/main.go                              |  12 +
 bing-cli/output/output.go                     |  24 ++
 15 files changed, 888 insertions(+)
 create mode 100644 bing-cli/.gitignore
 create mode 100644 bing-cli/.gitignore.baiduyun.uploading.cfg
 create mode 100644 bing-cli/ARCHAEOLOGY.md
 create mode 100644 bing-cli/README.md
 create mode 100644 bing-cli/bing/common.go
 create mode 100644 bing-cli/bing/common.go.baiduyun.uploading.cfg
 create mode 100644 bing-cli/bing/result.go
 create mode 100644 bing-cli/bing/result.go.baiduyun.uploading.cfg
 create mode 100644 bing-cli/bing/search.go
 create mode 100644 bing-cli/browser/client.go
 create mode 100644 bing-cli/cmd/root.go
 create mode 100644 bing-cli/go.mod
 create mode 100644 bing-cli/go.sum
 create mode 100644 bing-cli/main.go
 create mode 100644 bing-cli/output/output.go

diff --git a/bing-cli/.gitignore b/bing-cli/.gitignore
new file mode 100644
index 0000000..789fcb5
--- /dev/null
+++ b/bing-cli/.gitignore
@@ -0,0 +1,15 @@
+# Build output
+/bing-cli
+*.exe
+*.dll
+*.so
+*.dylib
+
+# Test binaries
+*.test
+*.out
+
+# Editors
+.vscode/
+.idea/
+.DS_Store
diff --git a/bing-cli/.gitignore.baiduyun.uploading.cfg b/bing-cli/.gitignore.baiduyun.uploading.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..2ee1ffa856784a0c8f8e3ad2f60d07668e84d888
GIT binary patch
literal 679
zcmV;Y0$BZqF-iDYjVh`4HCJ0Df~^-ztXiAJX}YXmS<2Q7pV<wkl>KYR&@NG(Jk2Kp
zqH`H(NyVN`@B<EhZO>)C<sIWj3M(8pT>!e6>o+Q6;s5*w#}wupl!TN1?r<+(UG<L<
z<wt{bBkP-~41V(|p^SaEkGH`N*SuW5_7-{^#`;OVBZsRx%g=U1-75;%c#;$hs-q*5
zuo#elXE&e`K?K?}tdjCBHyIJhFT>kaU>0R|dKN<E;d}I3Kg@Dq_wZm^snL_l5Fg^J
zT7zDCB@rfY%eA8h3nHBP<o|Kx-9*KGq3VHWK8M?S?pcr>C`fOHFV>m;fyd*Ab-(!O
z6>t^QWB5V4ssQPh85y5_zVOkqJr1}IGdR&i5cY0q<K?;80gjL`jBwY4gh@s&(j!S6
zcuZaJ0Ioy1ZQdQbacg2yQQDld!3SvoW!~q*%#r_+EOkPD(Rmt5AfX2q&~n}a8o>!r
z4fXS)=uu})|2Pha`+A`^w)EsG#a6#MSlb^}18S{(#BIJ_@yAf;JVjSwL$~3)ZdKra
zyVe!8nni8SAtvgR$mFB%?Qs6CMm)onv1*}+N4G^ZX!!AhG4IgC`oDFXx;XhHFhZ~H
zMhd8;2^g%RnB*4pcAzHfyf)v$xh$K^r3h?$$odTv(em9~VB`^T-{y9OX!ivNBUSmC
z)Mo@*CT^VXT~cYE?%+EQny?q3MYK7$?!JXeC2Cm@Nz47Qtbd@OBKkUu^7@aHbSO6?
zbNYpskJ~LjHhuVGcqtttWvy@7Aq8Etb`VG$7f4Qp`Z}<l;!=Hu6?-ea=17{$K&gOE
zxjZ88wM)^79_6L^{D2WrK-z=SRlbYX(Za|PpPxo!+ouHB;a^-Y2=Ih&dLKk0A=3{s
NOG165KzHsVsh2`eRU7~S

literal 0
HcmV?d00001

diff --git a/bing-cli/ARCHAEOLOGY.md b/bing-cli/ARCHAEOLOGY.md
new file mode 100644
index 0000000..36be479
--- /dev/null
+++ b/bing-cli/ARCHAEOLOGY.md
@@ -0,0 +1,97 @@
+# Site Archaeology — Bing Search
+
+Findings from applying the archaeology protocol against Bing (English + Chinese UI) on 2026-07-15. Merged from bing-cli-acc and updated for v2.
+
+## Feature A: `search <query>`
+
+**URL:** `GET https://www.bing.com/search?q=<urlencode(query)>&count=<N>&offset=<O>`
+
+- No auth required for basic search.
+- Results are SSR'd in the DOM — no XHR needed for page one.
+- Chinese market (`cc=cn&setlang=zh-Hans`) vs international (`cc=us&setlang=en`).
+- `count` max is ~50 per page. `offset` enables pagination.
+
+### DOM Structure
+
+Each organic result lives in:
+
+```html
+<li class="b_algo" iid="SERP.NNNN">
+  <style>...</style>
+  <h2><a href="https://www.bing.com/ck/a?...">Title text</a></h2>
+  <div class="b_attribution"><cite>https://example.com</cite></div>
+  <div class="b_caption"><p class="b_paractl">Snippet text...</p></div>
+</li>
+```
+
+**Selectors:**
+
+| Field   | Selector       | Notes |
+|---------|----------------|-------|
+| title   | `#b_results > li.b_algo h2 a` textContent | |
+| url     | `#b_results > li.b_algo .b_attribution cite` textContent | Display URL (domain only) |
+| snippet | `#b_results > li.b_algo .b_caption p` textContent | May include breadcrumb prefix |
+| source  | same as `cite` | |
+| bingHref| `h2 a` getAttribute("href") | Encrypted /ck/a redirect — resolved on Go side |
+
+### Extract Strategy
+
+Async IIFE with 8 s polling deadline (google-cli pattern):
+
+1. Check for consent interstitial (`location.host.startsWith('consent.')`).
+2. Poll `#b_results > li.b_algo` every 500 ms until results appear.
+3. Deduplicate by display URL (Set).
+4. Clean snippet: `replace(/\s+/g, " ")`, strip trailing "Read more", slice to 300.
+
+### Gotchas
+
+- **Encrypted href**: The `<h2 a>` `href` is a Bing redirect (`/ck/a?...&u=<encrypted>`). The CLI follows each redirect via HTTP GET and extracts the real URL from the response HTML body using a regex.
+- **Inline `<style>` in results**: Each `li.b_algo` contains inline `<style>`. Extract by selector, never `innerHTML`.
+- **Snippet prefix**: Chinese UI snippets sometimes start with `› ` (breadcrumb). Whitespace normalization handles it.
+- **Result count**: `#b_results > li.b_algo` typically returns 10–12 per page.
+- **Consent interstitial**: EU / anonymous browsers may hit `consent.bing.com`. Detected and reported as `consent_required`.
+
+### Known Failure Modes
+
+| Symptom | Likely Cause | Fix |
+|---------|-------------|-----|
+| `consent_required` | EU consent interstitial | Accept once in Chrome, retry |
+| `no_results` / empty items | Bing reflowed selectors | Re-run archaeology against `li.b_algo` |
+| `daemon_unreachable` | kimi-webbridge not running | Start Kimi Desktop App |
+| `extension_not_connected` | WebBridge extension not installed | Install from kimi.com/features/webbridge |
+| CDP context errors | Tab still loading | Handled by evaluateWithRetry (3 retries) |
+
+---
+
+## Feature B: `result <url>`
+
+**Delivery model:** Arbitrary page; DOM extraction via `evaluate`.
+
+### Extraction
+
+```json
+{
+  "url":         "location.href after redirects",
+  "title":       "document.title",
+  "description": "meta[name=description] → meta[property='og:description'] → ''",
+  "text":        "document.body.innerText capped at 5000 chars"
+}
+```
+
+### Gotchas
+
+- `document.body.innerText` begins with header/nav text — acceptable for MVP.
+- JS-heavy pages: if `text.length < 50`, retry once with a 2 s settle delay.
+- No network capture required.
+
+---
+
+## Daemon `evaluate` Protocol (Critical for Go Client)
+
+- Code runs as a top-level expression — `return <expr>` triggers `SyntaxError`.
+- The value of the last expression is the return value.
+- For async, wrap explicitly: `(async () => { ... })()`.
+- Daemon wraps every return as `{"type": "<type>", "value": <v>}`.
+- When code ends with `JSON.stringify(...)`, `type` is `"string"`.
+- Go client **must** unwrap this envelope before unmarshalling.
+- `EvaluateJSON` handles the unwrap automatically.
diff --git a/bing-cli/README.md b/bing-cli/README.md
new file mode 100644
index 0000000..78b9f14
--- /dev/null
+++ b/bing-cli/README.md
@@ -0,0 +1,103 @@
+# bing-cli
+
+CLI wrapper around Bing Search backed by the [kimi-webbridge](https://www.kimi.com/features/webbridge) browser daemon. Runs inside your real Chrome session — no API key needed — and emits JSON on stdout.
+
+## Commands
+
+| Command | Usage | Returns |
+|---|---|---|
+| `search` | `bing-cli search <query> [-n N] [-m cn\|us] [-o N] [-r]` | `{query, count, results: [{title, url, snippet, source}]}` |
+| `result` | `bing-cli result <url> [-r]` | `{url, title, description, text}` |
+
+All output:
+
+```json
+{"ok": true, "data": ...}
+```
+or on failure (non-zero exit):
+
+```json
+{"ok": false, "error": {"code": "...", "message": "..."}}
+```
+
+### Agent consumption (recommended)
+
+Use `--raw` (`-r`) to get clean JSON without the status wrapper — saves tokens:
+
+```bash
+bing-cli search "query" -r -n 10
+# → [{"title":"...","url":"...","snippet":"...","source":"..."}]
+```
+
+## Prerequisites
+
+**kimi-webbridge daemon** running on `127.0.0.1:10086` — install from https://www.kimi.com/features/webbridge.
+
+## Install
+
+**Binary** (Windows): copy `bing-cli.exe` into a directory on your `PATH`.
+
+**Build from source** (requires Go 1.26+):
+
+```bash
+go build -o bing-cli .
+./bing-cli search "claude code"
+```
+
+## Quick test
+
+```bash
+# English search
+bing-cli search "claude code" --count 3
+
+# Chinese search
+bing-cli search "牛仔裤面料" --market cn -r -n 5
+
+# International with pagination
+bing-cli search "rust async patterns" -m us -r -n 10 -o 10
+
+# Fetch page content
+bing-cli result "https://example.com/article"
+```
+
+## Flags (search)
+
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--market` | `-m` | `""` (auto) | `cn` (China), `us` (International) |
+| `--count` | `-n` | `10` | Results per page (max 50) |
+| `--offset` | `-o` | `0` | Pagination offset |
+| `--raw` | `-r` | `false` | Bare JSON array — no wrapper |
+
+## Layout
+
+```
+bing-cli/
+├── main.go                # entrypoint
+├── browser/client.go      # kimi-webbridge HTTP client (+ EvaluateJSON, Status)
+├── output/output.go       # JSON contract: {ok, data} / {ok, error}
+├── bing/
+│   ├── search.go          # search command backend (DOM extractor + /ck/a resolver)
+│   ├── result.go          # result command backend (page content extraction)
+│   └── common.go          # evaluateWithRetry + isTransientContextError
+├── cmd/
+│   └── root.go            # Cobra CLI definition (search + result)
+├── ARCHAEOLOGY.md         # DOM-selector field notes
+└── README.md              # this file
+```
+
+## Robustness
+
+- **CDP retry**: 3-level backoff (300ms → 700ms → 1500ms) for transient context errors.
+- **Consent detection**: Detects Bing privacy interstitials and reports a clear error.
+- **Async DOM polling**: Waits up to 8 s for results to render (defense against lazy loading).
+- **URL dedup**: Filters duplicate display URLs from the result set.
+- **/ck/a redirect resolution**: Follows Bing's encrypted redirect pages to extract real target URLs.
+- **JS-heavy page retry**: For `result`, retries with a 2 s settle delay if body text is < 50 chars.
+
+## Notes
+
+- Bing encrypts the real link target in the `href` of each result's `<h2 a>` (a proprietary redirect through `/ck/a`). The CLI automatically follows each redirect and extracts the real URL from the response HTML.
+- Selectors pinned to `#b_results > li.b_algo` + `h2 a` + `.b_attribution cite` + `.b_caption p`. If Bing reflows, re-run the archaeology protocol and update `bing/search.go`.
+- No login needed for basic search.
+- `cn.bing.com` auto-redirect may happen based on IP when no `--market` flag.
diff --git a/bing-cli/bing/common.go b/bing-cli/bing/common.go
new file mode 100644
index 0000000..6dc9431
--- /dev/null
+++ b/bing-cli/bing/common.go
@@ -0,0 +1,41 @@
+package bing
+
+import (
+	"strings"
+	"time"
+
+	"bing-cli/browser"
+)
+
+// evaluateWithRetry calls client.EvaluateJSON and retries on transient CDP
+// context errors with a three-level backoff: 300ms → 700ms → 1500ms.
+// Non-transient errors are returned immediately.
+func evaluateWithRetry(client *browser.Client, code string, v any) error {
+	delays := []time.Duration{300 * time.Millisecond, 700 * time.Millisecond, 1500 * time.Millisecond}
+	var lastErr error
+	for i, d := range delays {
+		if i > 0 {
+			time.Sleep(d)
+		}
+		err := client.EvaluateJSON(code, v)
+		if err == nil {
+			return nil
+		}
+		lastErr = err
+		if !isTransientContextError(err) {
+			return err
+		}
+	}
+	return lastErr
+}
+
+// isTransientContextError returns true when the error message indicates a
+// temporary CDP execution-context race (tab is still loading / has navigated).
+func isTransientContextError(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := err.Error()
+	return strings.Contains(msg, "Cannot find default execution context") ||
+		strings.Contains(msg, "Execution context was destroyed")
+}
diff --git a/bing-cli/bing/common.go.baiduyun.uploading.cfg b/bing-cli/bing/common.go.baiduyun.uploading.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..42d1c18171fba4c0437980c594130f205e5fa947
GIT binary patch
literal 685
zcmV;e0#f~kF-iDYjVh`4HCJ0Df~^-ztXiAJX}YXmS<2Q7pV<wkl>KYR&@NG(Jk2Kp
zqH`H(NyVN`@B<EhZO>)C<sIWj3M(8pT>!e7<T^PD&ieH*{RjC#mj1l^=RpZfQs}QM
z_E^|@FZl9?33tK|vV&lkwWQuv)y8wX|36m_!NY5{E{L=j_RD@B(k%tld6gavs--4?
z**BGmP8zZncqY+4qmADaGZ9M5RqWneMkjJ|Zwo}^+eYwHWW#iC`|)Q`snM0s19r`>
zQ>AZhAp|>i%8#A`19_f<%ldfL=3mfofWy#iGSH2B>j}ymct$<fD~Zqlhmz&fBkZfc
z7jQw;VE+@lp%Z|)91yNXrRCg{6koFpNf*>jNAYbG``WzI2d24UhkSt2giIE6)N@Bp
zDM$jQ0;m?hIfzc^Cuw2^QQ4c}!3=t7O55&~%aVeM6L3g)`A|ziBHJhv*+b<S56mWE
z9HsKE<yd1*{V@%P`+B7%-`n9M^lhXsRrD@IQ){7rzCycK*6CB^G-7glME&E!KvwK`
zo&Q9j$zOiac{%x$&;GKxzh&aQdnW3c_ARW4SN0b)DXIUGF72U+z_59>yFj2bFJ8a4
zM_K!&0~oELmf;ejE%hMkyEloGy)Vhnq6j#9o&Es}ud(n`WXc{1h3{woF5L+!DtPvt
z`(-;vYbNBncV1A6*Z(#IvaoUbR>^9E?z@3;DhvZ0HJi}Bs86DaF1~Js_wtUMcOx!c
zFxQHczu5#cawL^ALM9OtX@p~)a0*bid=yU*3?~i0^)`T#%U(I$cp?g}@l3DSWT46k
z#C!$i{%yUbIq&Y|{+m!+1JT9aTm6rh+kuZ+l!8HHnyVSmupeP$9qHXNc^g7JdYy0v
TPev^H3uN~rqsYyKN}0bBhg(-&

literal 0
HcmV?d00001

diff --git a/bing-cli/bing/result.go b/bing-cli/bing/result.go
new file mode 100644
index 0000000..f3074cf
--- /dev/null
+++ b/bing-cli/bing/result.go
@@ -0,0 +1,73 @@
+package bing
+
+import (
+	"fmt"
+
+	"bing-cli/browser"
+)
+
+// PageResult holds the extracted content from a fetched page.
+type PageResult struct {
+	URL         string `json:"url"`
+	Title       string `json:"title"`
+	Description string `json:"description"`
+	Text        string `json:"text"`
+}
+
+// resultExtractJS extracts page metadata and body text.
+// For JS-heavy pages where text hasn't rendered yet, the caller should
+// retry once after a 1.5 s wait if text length < 50.
+const resultExtractJS = `(() => {
+  const meta = document.querySelector('meta[name="description"]');
+  const og   = document.querySelector('meta[property="og:description"]');
+  return JSON.stringify({
+    url:         location.href,
+    title:       document.title,
+    description: meta ? meta.getAttribute('content') : (og ? og.getAttribute('content') : ''),
+    text:        (document.body ? document.body.innerText : '').slice(0, 5000)
+  });
+})()`
+
+// FetchResult navigates to url and extracts title, description, and text.
+// JS-heavy pages get a single retry after a 1.5 s settle delay.
+func FetchResult(client *browser.Client, targetURL string) (*PageResult, error) {
+	if err := client.Navigate(targetURL); err != nil {
+		return nil, fmt.Errorf("navigate: %w", err)
+	}
+
+	var page PageResult
+	if err := evaluateWithRetry(client, resultExtractJS, &page); err != nil {
+		return nil, fmt.Errorf("extract: %w", err)
+	}
+
+	// JS-heavy pages: if body text is suspiciously short, wait and retry once.
+	if len(page.Text) < 50 {
+		// Use a raw Evaluate call so we can sleep inside JS; the daemon
+		// doesn't support time.Sleep in Go, so we re-evaluate after a
+		// short settle via a simple JS delay.
+		settleJS := `(async () => {
+		  await new Promise(r => setTimeout(r, 2000));
+		  return JSON.stringify({
+		    url:         location.href,
+		    title:       document.title,
+		    description: (() => {
+		      const m = document.querySelector('meta[name="description"]');
+		      if (m) return m.getAttribute('content');
+		      const og = document.querySelector('meta[property="og:description"]');
+		      return og ? og.getAttribute('content') : '';
+		    })(),
+		    text: (document.body ? document.body.innerText : '').slice(0, 5000)
+		  });
+		})()`
+		var retry PageResult
+		if err := client.EvaluateJSON(settleJS, &retry); err != nil {
+			// Fall back to the original (possibly short) result.
+			return &page, nil
+		}
+		if len(retry.Text) > len(page.Text) {
+			page = retry
+		}
+	}
+
+	return &page, nil
+}
diff --git a/bing-cli/bing/result.go.baiduyun.uploading.cfg b/bing-cli/bing/result.go.baiduyun.uploading.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..594bf40bf5ef764ab44b4575a6fdc535f3016527
GIT binary patch
literal 684
zcmV;d0#p5lF-iDYjVh`4HCJ0Df~^-ztXiAJX}YXmS<2Q7pV<wkl>KYR&@NG(Jk2Kp
zqH`H(NyVN`@B<EhZO>)C<sIWj3M(8pT>!bA>oPeC&ieH*{RjC#mj1l^=RpZfQs}QM
z_E^|@FZl9?33tK|vV&lkwWQuv)y8wX|36m_!NY5{E{L=j_RD@B(k%tld6gavs--4?
z**BGmP8zZncqY+4qmADaGZ9M5RqWneMkjJ|Zwo}^+eYwHWW#iC`|)Q`snM0s19r`>
zQ>AZhAp|>i%8#A`19_f<%ldfL=3mfofWy#iGK7tPzFo~rE*d)CE{Msmg_G)oA-(wI
zM|VfkH~U5Iq7#6*91yNXrRCg{6koFpNf*>jNAYbG``WzI2d24UhkVr1ff+(`ge4nE
zAWZ|HQmPlQX^J1ad^u$RSB{^zln;7oO55&~%aVeM6L3g)`A|ziBHJhv*+b<S56mWE
z9HsKE<z8n)_%RKK`+cD{w)EsG#a6#MSlb^}18S{(#BIJ_@yAf;JVjSwL$~3)ZdKra
zyVe!8nni8SAtvdT$p4|c>tpe=W(LrT>2<T3Mf6l9IQjmaG3}%K|Fv_olWFlgFkYkW
z5D)mER8Fe!&Ab<?Ch{V`wK9vqxgp8R_YOFC%&!FiyxiVUXu>!k)Z}ICNAe6H4OaD$
z^Fkh7Y;5MhSX)`T^5ZoMx1C(EN6Qtj_M@C=2q8!fH|74lq(_>wJ)t#<_V$92bs{8A
zUHOThx8Xh@ZGV?seIpwcU%qgHD*#o#aT81w1T=Ag@H~d3@l7U&dQCjJ^<TL9RkhY%
z)etG}|0mI<73A-(sm>l$2A7D{T=d1+)P%_tpM^*($E^j(u>>J46}rw&PYgycZNEVi
SQxGodaY5@Kt<CSNPmtss=T{T}

literal 0
HcmV?d00001

diff --git a/bing-cli/bing/search.go b/bing-cli/bing/search.go
new file mode 100644
index 0000000..45df42d
--- /dev/null
+++ b/bing-cli/bing/search.go
@@ -0,0 +1,206 @@
+package bing
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"bing-cli/browser"
+)
+
+const baseURL = "https://www.bing.com/search"
+
+// ErrConsentRequired is returned when Bing serves a consent/privacy
+// interstitial. The user must accept it once in Chrome, then retry.
+type ErrConsentRequired struct{}
+
+func (e ErrConsentRequired) Error() string {
+	return "Bing served a consent interstitial. Accept once in Chrome, then retry."
+}
+
+// bingRedirectRe matches the real target URL embedded in Bing's /ck/a redirect page.
+var bingRedirectRe = regexp.MustCompile(`https?://[a-zA-Z0-9][a-zA-Z0-9._/-]*[a-zA-Z0-9/]`)
+
+// SearchResult is one item in the Bing search result list.
+type SearchResult struct {
+	Title   string `json:"title"`
+	URL     string `json:"url"`
+	Snippet string `json:"snippet"`
+	Source  string `json:"source"`
+}
+
+// SearchOptions bundles all search parameters.
+type SearchOptions struct {
+	Query  string
+	Market string // "cn", "us", "" (auto)
+	Count  int
+	Offset int
+}
+
+// searchExtractJS is the merged extractor:
+//   - Async polling (8 s deadline) — google-cli pattern
+//   - Consent interstitial detection — google-cli pattern
+//   - Bing selectors (#b_results > li.b_algo) — v2
+//   - bingHref capture for /ck/a redirect resolution — acc
+//   - URL dedup — google-cli pattern
+//   - Snippet cleaning (whitespace + trailing "Read more") — both
+const searchExtractJS = `(async () => {
+  const deadline = Date.now() + 8000;
+  let results = [];
+
+  while (Date.now() < deadline) {
+    if (location.host.startsWith('consent.')) {
+      return JSON.stringify({consent: true, items: []});
+    }
+
+    const items = document.querySelectorAll("#b_results > li.b_algo");
+    if (items.length > 0) {
+      const seen = new Set();
+      results = Array.from(items).map(el => {
+        const h2 = el.querySelector("h2 a");
+        const cite = el.querySelector(".b_attribution cite, cite");
+        const p = el.querySelector(".b_caption p");
+        if (!h2) return null;
+        const displayURL = cite ? cite.textContent.trim() : "";
+        if (!displayURL || seen.has(displayURL)) return null;
+        seen.add(displayURL);
+        return {
+          title:    h2.textContent.trim(),
+          url:      displayURL,
+          snippet:  (p ? p.textContent.trim().replace(/\s+/g, " ") : "")
+                      .replace(/\s*Read more\.?$/, "")
+                      .slice(0, 300),
+          source:   cite ? cite.textContent.trim() : "",
+          bingHref: h2.getAttribute("href") || ""
+        };
+      }).filter(Boolean);
+      if (results.length > 0) break;
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  return JSON.stringify({consent: false, items: results});
+})()`
+
+// resolveBingURL follows Bing's /ck/a redirect and extracts the real target
+// URL from the HTML response body. Falls back to the original URL on failure.
+func resolveBingURL(bingURL string) string {
+	if !strings.Contains(bingURL, "/ck/a") || !strings.Contains(bingURL, "u=") {
+		return bingURL
+	}
+	client := &http.Client{Timeout: 8 * time.Second}
+	resp, err := client.Get(bingURL)
+	if err != nil {
+		return bingURL
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return bingURL
+	}
+	body, _ := io.ReadAll(resp.Body)
+	matches := bingRedirectRe.FindAllString(string(body), -1)
+	for _, m := range matches {
+		if !strings.Contains(m, "bing.com/ck") {
+			return m
+		}
+	}
+	return bingURL
+}
+
+// Search navigates to the Bing SERP and extracts organic results.
+func Search(client *browser.Client, opts SearchOptions) ([]SearchResult, error) {
+	params := url.Values{}
+	params.Set("q", opts.Query)
+	if opts.Count > 0 {
+		params.Set("count", fmt.Sprintf("%d", opts.Count))
+	} else {
+		params.Set("count", "10")
+	}
+	if opts.Offset > 0 {
+		params.Set("offset", fmt.Sprintf("%d", opts.Offset))
+	}
+	if opts.Market != "" {
+		switch opts.Market {
+		case "cn", "zh-CN", "zh":
+			params.Set("cc", "cn")
+			params.Set("setlang", "zh-Hans")
+		case "us", "en-US", "en":
+			params.Set("cc", "us")
+			params.Set("setlang", "en")
+		default:
+			params.Set("cc", opts.Market)
+		}
+	}
+
+	searchURL := baseURL + "?" + params.Encode()
+
+	if err := client.Navigate(searchURL); err != nil {
+		return nil, fmt.Errorf("navigate: %w", err)
+	}
+
+	// Extract results with CDP retry.
+	var rawPayload struct {
+		Consent bool `json:"consent"`
+		Items   []struct {
+			Title    string `json:"title"`
+			URL      string `json:"url"`
+			Snippet  string `json:"snippet"`
+			Source   string `json:"source"`
+			BingHref string `json:"bingHref"`
+		} `json:"items"`
+	}
+
+	if err := evaluateWithRetry(client, searchExtractJS, &rawPayload); err != nil {
+		return nil, fmt.Errorf("extract: %w", err)
+	}
+
+	if rawPayload.Consent {
+		return nil, ErrConsentRequired{}
+	}
+
+	results := make([]SearchResult, 0, len(rawPayload.Items))
+	for _, item := range rawPayload.Items {
+		finalURL := item.URL
+		// Resolve Bing's encrypted /ck/a redirect to the real URL.
+		if item.BingHref != "" && strings.Contains(item.BingHref, "/ck/a") {
+			if resolved := resolveBingURL(item.BingHref); resolved != item.BingHref {
+				finalURL = resolved
+			}
+		}
+		results = append(results, SearchResult{
+			Title:   item.Title,
+			URL:     finalURL,
+			Snippet: item.Snippet,
+			Source:  item.Source,
+		})
+	}
+
+	return results, nil
+}
+
+// FormatResults returns a human-readable string for terminal display (stderr).
+func FormatResults(results []SearchResult, query string) string {
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("Bing Search: %s\n", query))
+	sb.WriteString(strings.Repeat("─", 80) + "\n")
+	for i, r := range results {
+		sb.WriteString(fmt.Sprintf("\n%d. %s\n", i+1, r.Title))
+		sb.WriteString(fmt.Sprintf("   %s\n", r.URL))
+		if r.Snippet != "" {
+			sb.WriteString(fmt.Sprintf("   %s\n", truncate(r.Snippet, 200)))
+		}
+	}
+	return sb.String()
+}
+
+func truncate(s string, n int) string {
+	runes := []rune(s)
+	if len(runes) <= n {
+		return s
+	}
+	return string(runes[:n]) + "…"
+}
diff --git a/bing-cli/browser/client.go b/bing-cli/browser/client.go
new file mode 100644
index 0000000..ba397ff
--- /dev/null
+++ b/bing-cli/browser/client.go
@@ -0,0 +1,120 @@
+package browser
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+)
+
+const DefaultDaemonURL = "http://127.0.0.1:10086"
+
+type Client struct {
+	baseURL string
+	session string
+	http    *http.Client
+}
+
+func NewClient(session string) *Client {
+	return &Client{
+		baseURL: DefaultDaemonURL,
+		session: session,
+		http:    &http.Client{Timeout: 90 * time.Second},
+	}
+}
+
+// Status reports whether the kimi-webbridge daemon and its Chrome extension
+// are alive. Always call this before Navigate/Evaluate so the user gets a
+// clear diagnostic when the bridge is down.
+type Status struct {
+	Running            bool   `json:"running"`
+	ExtensionConnected bool   `json:"extension_connected"`
+	ExtensionVersion   string `json:"extension_version"`
+	Version            string `json:"version"`
+}
+
+func (c *Client) Status() (*Status, error) {
+	resp, err := c.http.Get(c.baseURL + "/status")
+	if err != nil {
+		return nil, fmt.Errorf("daemon unreachable at %s: %w", c.baseURL, err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	var s Status
+	if err := json.Unmarshal(body, &s); err != nil {
+		return nil, fmt.Errorf("parse status: %w (body=%s)", err, string(body))
+	}
+	return &s, nil
+}
+
+func (c *Client) Call(action string, args map[string]any) (json.RawMessage, error) {
+	body, _ := json.Marshal(map[string]any{
+		"action":  action,
+		"session": c.session,
+		"args":    args,
+	})
+	resp, err := c.http.Post(c.baseURL+"/command", "application/json", bytes.NewReader(body))
+	if err != nil {
+		return nil, fmt.Errorf("daemon unreachable: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var result struct {
+		OK    bool            `json:"ok"`
+		Data  json.RawMessage `json:"data"`
+		Error *struct {
+			Code    string `json:"code"`
+			Message string `json:"message"`
+		} `json:"error"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, err
+	}
+	if !result.OK {
+		return nil, fmt.Errorf("%s: %s", result.Error.Code, result.Error.Message)
+	}
+	return result.Data, nil
+}
+
+func (c *Client) Navigate(url string) error {
+	_, err := c.Call("navigate", map[string]any{"url": url, "newTab": false})
+	return err
+}
+
+// Evaluate runs `code` as a top-level JS expression in the active tab.
+// The daemon wraps the result as {"type": "...", "value": ...}. For structured
+// data, prefer EvaluateJSON, which unwraps the envelope for you.
+func (c *Client) Evaluate(code string) (json.RawMessage, error) {
+	return c.Call("evaluate", map[string]any{"code": code})
+}
+
+// EvaluateJSON runs `code` and decodes the stringified JSON it returns into v.
+// `code` must end with a `JSON.stringify(...)` expression; the daemon reports
+// that as {"type":"string","value":"<stringified JSON>"}.
+func (c *Client) EvaluateJSON(code string, v any) error {
+	raw, err := c.Evaluate(code)
+	if err != nil {
+		return err
+	}
+	var env struct {
+		Type  string `json:"type"`
+		Value string `json:"value"`
+	}
+	if err := json.Unmarshal(raw, &env); err != nil {
+		return fmt.Errorf("decode evaluate envelope: %w", err)
+	}
+	if env.Type != "string" {
+		return fmt.Errorf("expected evaluate type=string, got %q — did the code end with JSON.stringify(...)?", env.Type)
+	}
+	if err := json.Unmarshal([]byte(env.Value), v); err != nil {
+		return fmt.Errorf("decode evaluate value: %w", err)
+	}
+	return nil
+}
+
+func (c *Client) Close() error {
+	_, err := c.Call("close_session", map[string]any{})
+	return err
+}
diff --git a/bing-cli/cmd/root.go b/bing-cli/cmd/root.go
new file mode 100644
index 0000000..771e01f
--- /dev/null
+++ b/bing-cli/cmd/root.go
@@ -0,0 +1,178 @@
+package cmd
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+
+	"bing-cli/bing"
+	"bing-cli/browser"
+	"bing-cli/output"
+
+	"github.com/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "bing-cli",
+	Short: "Bing search CLI powered by browser automation",
+	Long: `bing-cli automates Bing Search by running inside the user's real browser
+session via kimi-webbridge (http://127.0.0.1:10086). All commands emit JSON on
+stdout: {"ok":true,"data":...} on success, {"ok":false,"error":{...}} on failure.
+Every command exits non-zero on failure.
+
+No API key required. Results come from real Bing pages, avoiding bot detection.
+Use --market to switch between Chinese and international results.
+
+Examples:
+  bing-cli search "rust programming"
+  bing-cli search "牛仔裤" --market cn
+  bing-cli search "AI agents" --market us --count 5`,
+}
+
+func Execute() error {
+	return rootCmd.Execute()
+}
+
+func init() {
+	// ---- search ----
+	searchCmd := &cobra.Command{
+		Use:   "search <query>",
+		Short: "Search Bing and return structured results",
+		Long: `Navigates to bing.com and extracts the organic result list.
+
+Examples:
+  bing-cli search "claude code"
+  bing-cli search "英格兰 阿根廷 世界杯" --count 5
+  bing-cli search "牛仔裤面料" --market cn --raw
+`,
+		Args: cobra.MinimumNArgs(1),
+		Run:  runSearch,
+	}
+	searchCmd.Flags().StringP("market", "m", "", "Market: cn (China), us (International), or empty (auto)")
+	searchCmd.Flags().IntP("count", "n", 10, "Number of results (max 50)")
+	searchCmd.Flags().IntP("offset", "o", 0, "Result offset for pagination")
+	searchCmd.Flags().BoolP("raw", "r", false, "Output raw JSON array only (for agent consumption)")
+	searchCmd.SilenceUsage = true
+	searchCmd.SilenceErrors = true
+	rootCmd.AddCommand(searchCmd)
+
+	// ---- result ----
+	resultCmd := &cobra.Command{
+		Use:   "result <url>",
+		Short: "Fetch a page and extract title, description, and text",
+		Long: `Navigates to a URL and extracts structured page content.
+
+Examples:
+  bing-cli result "https://example.com/article"
+`,
+		Args: cobra.ExactArgs(1),
+		Run:  runResult,
+	}
+	resultCmd.Flags().BoolP("raw", "r", false, "Output raw JSON only (for agent consumption)")
+	resultCmd.SilenceUsage = true
+	resultCmd.SilenceErrors = true
+	rootCmd.AddCommand(resultCmd)
+}
+
+// daemonCheck verifies kimi-webbridge is reachable and the extension is
+// connected. Exits with a clear diagnostic on failure.
+func daemonCheck(client *browser.Client) {
+	st, err := client.Status()
+	if err != nil {
+		output.Error("daemon_unreachable", err.Error())
+		os.Exit(1)
+	}
+	if !st.Running {
+		output.Error("daemon_not_running",
+			"kimi-webbridge daemon is not running (open the Kimi Desktop App)")
+		os.Exit(1)
+	}
+	if !st.ExtensionConnected {
+		output.Error("extension_not_connected",
+			"Chrome WebBridge extension is not connected (see https://www.kimi.com/features/webbridge)")
+		os.Exit(1)
+	}
+}
+
+func runSearch(cmd *cobra.Command, args []string) {
+	query := strings.Join(args, " ")
+	market, _ := cmd.Flags().GetString("market")
+	count, _ := cmd.Flags().GetInt("count")
+	offset, _ := cmd.Flags().GetInt("offset")
+	raw, _ := cmd.Flags().GetBool("raw")
+
+	if count < 1 {
+		count = 1
+	}
+	if count > 50 {
+		count = 50
+	}
+
+	client := browser.NewClient("bing-cli")
+	defer client.Close()
+
+	daemonCheck(client)
+
+	results, err := bing.Search(client, bing.SearchOptions{
+		Query:  query,
+		Market: market,
+		Count:  count,
+		Offset: offset,
+	})
+	if err != nil {
+		var consentErr bing.ErrConsentRequired
+		if errors.As(err, &consentErr) {
+			output.Error("consent_required", err.Error())
+			os.Exit(1)
+		}
+		if strings.Contains(err.Error(), "daemon unreachable") {
+			output.Error("daemon_unreachable", err.Error())
+			os.Exit(1)
+		}
+		output.Error("search_failed", err.Error())
+		os.Exit(1)
+	}
+
+	if results == nil {
+		results = []bing.SearchResult{}
+	}
+
+	if raw {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetEscapeHTML(false)
+		enc.Encode(results)
+	} else {
+		output.Success(map[string]any{
+			"query":   query,
+			"count":   len(results),
+			"results": results,
+		})
+		fmt.Fprint(os.Stderr, bing.FormatResults(results, query))
+	}
+}
+
+func runResult(cmd *cobra.Command, args []string) {
+	targetURL := args[0]
+	raw, _ := cmd.Flags().GetBool("raw")
+
+	client := browser.NewClient("bing-cli")
+	defer client.Close()
+
+	daemonCheck(client)
+
+	page, err := bing.FetchResult(client, targetURL)
+	if err != nil {
+		output.Error("result_failed", err.Error())
+		os.Exit(1)
+	}
+
+	if raw {
+		enc := json.NewEncoder(os.Stdout)
+		enc.SetEscapeHTML(false)
+		enc.Encode(page)
+	} else {
+		output.Success(page)
+	}
+}
diff --git a/bing-cli/go.mod b/bing-cli/go.mod
new file mode 100644
index 0000000..6b7e28e
--- /dev/null
+++ b/bing-cli/go.mod
@@ -0,0 +1,9 @@
+module bing-cli
+
+go 1.26.5
+
+require (
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/spf13/cobra v1.10.2 // indirect
+	github.com/spf13/pflag v1.0.9 // indirect
+)
diff --git a/bing-cli/go.sum b/bing-cli/go.sum
new file mode 100644
index 0000000..a6ee3e0
--- /dev/null
+++ b/bing-cli/go.sum
@@ -0,0 +1,10 @@
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/bing-cli/main.go b/bing-cli/main.go
new file mode 100644
index 0000000..9643a4e
--- /dev/null
+++ b/bing-cli/main.go
@@ -0,0 +1,12 @@
+package main
+
+import (
+	"bing-cli/cmd"
+	"os"
+)
+
+func main() {
+	if err := cmd.Execute(); err != nil {
+		os.Exit(1)
+	}
+}
diff --git a/bing-cli/output/output.go b/bing-cli/output/output.go
new file mode 100644
index 0000000..4341740
--- /dev/null
+++ b/bing-cli/output/output.go
@@ -0,0 +1,24 @@
+package output
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+func Success(data any) {
+	printJSON(map[string]any{"ok": true, "data": data})
+}
+
+func Error(code, message string) {
+	printJSON(map[string]any{"ok": false, "error": map[string]any{"code": code, "message": message}})
+}
+
+func printJSON(v any) {
+	enc := json.NewEncoder(os.Stdout)
+	enc.SetEscapeHTML(false)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(v); err != nil {
+		fmt.Fprintf(os.Stderr, "output error: %v\n", err)
+	}
+}

From 248963b388280e3e2ef910411ddc6065fc23ca86 Mon Sep 17 00:00:00 2001
From: emotion04 <1695617871@qq.com>
Date: Mon, 20 Jul 2026 17:25:31 +0800
Subject: [PATCH 2/2] =?UTF-8?q?refactor:=20=E7=AE=80=E5=8C=96=20CLI=20?=
 =?UTF-8?q?=E6=8E=A5=E5=8F=A3=EF=BC=8C=E8=BE=93=E5=87=BA=E5=8E=9F=E5=A7=8B?=
 =?UTF-8?q?=20JSON?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

针对互联网噪声，多次搬运复制的情况添加 -u 去重功能。多条相似内容自动 fallback。

- 移除 result 命令、daemonCheck（守护进程检查）以及 --raw 参数
- stdout 默认返回原始 JSON 数组（面向 Agent 优先设计）
- --unique / -u：标题相似度去重 + 每域名最多 3 条
- --human / -H：可选，stderr 输出人类可读文本
- 默认市场设为 us（国际版）
- 移除守护进程健康检查（让错误自然暴露）
- 新增 CLAUDE.md 架构文档

Co-Authored-By: Claude <noreply@anthropic.com>
---
 bing-cli/.gitignore.baiduyun.uploading.cfg    | Bin 679 -> 0 bytes
 bing-cli/CLAUDE.md                            |  46 +++
 .../bing/common.go.baiduyun.uploading.cfg     | Bin 685 -> 0 bytes
 .../bing/result.go.baiduyun.uploading.cfg     | Bin 684 -> 0 bytes
 bing-cli/bing/search.go                       | 126 ++++++-
 bing-cli/cmd/root.go                          | 143 ++------
 bing-cli/root.go                              |  87 +++++
 bing-cli/search.go                            | 328 ++++++++++++++++++
 8 files changed, 611 insertions(+), 119 deletions(-)
 delete mode 100644 bing-cli/.gitignore.baiduyun.uploading.cfg
 create mode 100644 bing-cli/CLAUDE.md
 delete mode 100644 bing-cli/bing/common.go.baiduyun.uploading.cfg
 delete mode 100644 bing-cli/bing/result.go.baiduyun.uploading.cfg
 create mode 100644 bing-cli/root.go
 create mode 100644 bing-cli/search.go

diff --git a/bing-cli/.gitignore.baiduyun.uploading.cfg b/bing-cli/.gitignore.baiduyun.uploading.cfg
deleted file mode 100644
index 2ee1ffa856784a0c8f8e3ad2f60d07668e84d888..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 679
zcmV;Y0$BZqF-iDYjVh`4HCJ0Df~^-ztXiAJX}YXmS<2Q7pV<wkl>KYR&@NG(Jk2Kp
zqH`H(NyVN`@B<EhZO>)C<sIWj3M(8pT>!e6>o+Q6;s5*w#}wupl!TN1?r<+(UG<L<
z<wt{bBkP-~41V(|p^SaEkGH`N*SuW5_7-{^#`;OVBZsRx%g=U1-75;%c#;$hs-q*5
zuo#elXE&e`K?K?}tdjCBHyIJhFT>kaU>0R|dKN<E;d}I3Kg@Dq_wZm^snL_l5Fg^J
zT7zDCB@rfY%eA8h3nHBP<o|Kx-9*KGq3VHWK8M?S?pcr>C`fOHFV>m;fyd*Ab-(!O
z6>t^QWB5V4ssQPh85y5_zVOkqJr1}IGdR&i5cY0q<K?;80gjL`jBwY4gh@s&(j!S6
zcuZaJ0Ioy1ZQdQbacg2yQQDld!3SvoW!~q*%#r_+EOkPD(Rmt5AfX2q&~n}a8o>!r
z4fXS)=uu})|2Pha`+A`^w)EsG#a6#MSlb^}18S{(#BIJ_@yAf;JVjSwL$~3)ZdKra
zyVe!8nni8SAtvgR$mFB%?Qs6CMm)onv1*}+N4G^ZX!!AhG4IgC`oDFXx;XhHFhZ~H
zMhd8;2^g%RnB*4pcAzHfyf)v$xh$K^r3h?$$odTv(em9~VB`^T-{y9OX!ivNBUSmC
z)Mo@*CT^VXT~cYE?%+EQny?q3MYK7$?!JXeC2Cm@Nz47Qtbd@OBKkUu^7@aHbSO6?
zbNYpskJ~LjHhuVGcqtttWvy@7Aq8Etb`VG$7f4Qp`Z}<l;!=Hu6?-ea=17{$K&gOE
zxjZ88wM)^79_6L^{D2WrK-z=SRlbYX(Za|PpPxo!+ouHB;a^-Y2=Ih&dLKk0A=3{s
NOG165KzHsVsh2`eRU7~S

diff --git a/bing-cli/CLAUDE.md b/bing-cli/CLAUDE.md
new file mode 100644
index 0000000..ff11161
--- /dev/null
+++ b/bing-cli/CLAUDE.md
@@ -0,0 +1,46 @@
+# bing-cli Architecture
+
+## Design Principles
+
+- **CLI stays simple** — one action per command, no orchestration. Agent composes calls.
+- **Raw JSON by default** — primary consumer is AI agents, not humans.
+- **No API key** — uses kimi-webbridge for real browser sessions → cookies → no bot detection.
+
+## Dedup Strategy
+
+| Flag | Behavior |
+|------|----------|
+| *(none)* | Raw Bing top 10, no filtering |
+| `-u` | Title dedup (>80% char overlap) + max 3 per domain |
+
+Only `-u` triggers dedup. Default is pass-through — agent decides if results are too noisy and retries with `-u`.
+
+## Market Strategy
+
+Default is `-m us` (international). Bing's `cc` parameter controls the market. Only use `-m cn` when Chinese-local sources (Baidu/Zhihu/etc) are specifically needed.
+
+## Platform Patterns
+
+### General Search Engines (Bing, Google, Baidu, Sogou)
+- Same strategy: default pass-through, `-u` for dedup
+- Domain diversity matters — results from multiple sources
+
+### Platform-Internal Search (Xiaohongshu, Douyin, WeChat)
+- All results from same domain → `-u` meaningless
+- Need different dedup (content-based, not domain-based)
+- Separate CLI per platform
+
+## Project Structure
+
+```
+bing-cli/
+├── main.go           # Entry point
+├── browser/          # WebBridge HTTP client (reusable across all CLI tools)
+│   └── client.go
+├── output/           # JSON output helpers
+│   └── output.go
+├── bing/             # Bing-specific search logic
+│   └── search.go
+└── cmd/              # CLI commands (cobra)
+    └── root.go
+```
diff --git a/bing-cli/bing/common.go.baiduyun.uploading.cfg b/bing-cli/bing/common.go.baiduyun.uploading.cfg
deleted file mode 100644
index 42d1c18171fba4c0437980c594130f205e5fa947..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 685
zcmV;e0#f~kF-iDYjVh`4HCJ0Df~^-ztXiAJX}YXmS<2Q7pV<wkl>KYR&@NG(Jk2Kp
zqH`H(NyVN`@B<EhZO>)C<sIWj3M(8pT>!e7<T^PD&ieH*{RjC#mj1l^=RpZfQs}QM
z_E^|@FZl9?33tK|vV&lkwWQuv)y8wX|36m_!NY5{E{L=j_RD@B(k%tld6gavs--4?
z**BGmP8zZncqY+4qmADaGZ9M5RqWneMkjJ|Zwo}^+eYwHWW#iC`|)Q`snM0s19r`>
zQ>AZhAp|>i%8#A`19_f<%ldfL=3mfofWy#iGSH2B>j}ymct$<fD~Zqlhmz&fBkZfc
z7jQw;VE+@lp%Z|)91yNXrRCg{6koFpNf*>jNAYbG``WzI2d24UhkSt2giIE6)N@Bp
zDM$jQ0;m?hIfzc^Cuw2^QQ4c}!3=t7O55&~%aVeM6L3g)`A|ziBHJhv*+b<S56mWE
z9HsKE<yd1*{V@%P`+B7%-`n9M^lhXsRrD@IQ){7rzCycK*6CB^G-7glME&E!KvwK`
zo&Q9j$zOiac{%x$&;GKxzh&aQdnW3c_ARW4SN0b)DXIUGF72U+z_59>yFj2bFJ8a4
zM_K!&0~oELmf;ejE%hMkyEloGy)Vhnq6j#9o&Es}ud(n`WXc{1h3{woF5L+!DtPvt
z`(-;vYbNBncV1A6*Z(#IvaoUbR>^9E?z@3;DhvZ0HJi}Bs86DaF1~Js_wtUMcOx!c
zFxQHczu5#cawL^ALM9OtX@p~)a0*bid=yU*3?~i0^)`T#%U(I$cp?g}@l3DSWT46k
z#C!$i{%yUbIq&Y|{+m!+1JT9aTm6rh+kuZ+l!8HHnyVSmupeP$9qHXNc^g7JdYy0v
TPev^H3uN~rqsYyKN}0bBhg(-&

diff --git a/bing-cli/bing/result.go.baiduyun.uploading.cfg b/bing-cli/bing/result.go.baiduyun.uploading.cfg
deleted file mode 100644
index 594bf40bf5ef764ab44b4575a6fdc535f3016527..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 684
zcmV;d0#p5lF-iDYjVh`4HCJ0Df~^-ztXiAJX}YXmS<2Q7pV<wkl>KYR&@NG(Jk2Kp
zqH`H(NyVN`@B<EhZO>)C<sIWj3M(8pT>!bA>oPeC&ieH*{RjC#mj1l^=RpZfQs}QM
z_E^|@FZl9?33tK|vV&lkwWQuv)y8wX|36m_!NY5{E{L=j_RD@B(k%tld6gavs--4?
z**BGmP8zZncqY+4qmADaGZ9M5RqWneMkjJ|Zwo}^+eYwHWW#iC`|)Q`snM0s19r`>
zQ>AZhAp|>i%8#A`19_f<%ldfL=3mfofWy#iGK7tPzFo~rE*d)CE{Msmg_G)oA-(wI
zM|VfkH~U5Iq7#6*91yNXrRCg{6koFpNf*>jNAYbG``WzI2d24UhkVr1ff+(`ge4nE
zAWZ|HQmPlQX^J1ad^u$RSB{^zln;7oO55&~%aVeM6L3g)`A|ziBHJhv*+b<S56mWE
z9HsKE<z8n)_%RKK`+cD{w)EsG#a6#MSlb^}18S{(#BIJ_@yAf;JVjSwL$~3)ZdKra
zyVe!8nni8SAtvdT$p4|c>tpe=W(LrT>2<T3Mf6l9IQjmaG3}%K|Fv_olWFlgFkYkW
z5D)mER8Fe!&Ab<?Ch{V`wK9vqxgp8R_YOFC%&!FiyxiVUXu>!k)Z}ICNAe6H4OaD$
z^Fkh7Y;5MhSX)`T^5ZoMx1C(EN6Qtj_M@C=2q8!fH|74lq(_>wJ)t#<_V$92bs{8A
zUHOThx8Xh@ZGV?seIpwcU%qgHD*#o#aT81w1T=Ag@H~d3@l7U&dQCjJ^<TL9RkhY%
z)etG}|0mI<73A-(sm>l$2A7D{T=d1+)P%_tpM^*($E^j(u>>J46}rw&PYgycZNEVi
SQxGodaY5@Kt<CSNPmtss=T{T}

diff --git a/bing-cli/bing/search.go b/bing-cli/bing/search.go
index 45df42d..43e226a 100644
--- a/bing-cli/bing/search.go
+++ b/bing-cli/bing/search.go
@@ -39,6 +39,7 @@ type SearchOptions struct {
 	Market string // "cn", "us", "" (auto)
 	Count  int
 	Offset int
+	Unique bool // title dedup (>80% overlap) + max 3 per domain
 }
 
 // searchExtractJS is the merged extractor:
@@ -115,8 +116,17 @@ func resolveBingURL(bingURL string) string {
 func Search(client *browser.Client, opts SearchOptions) ([]SearchResult, error) {
 	params := url.Values{}
 	params.Set("q", opts.Query)
-	if opts.Count > 0 {
-		params.Set("count", fmt.Sprintf("%d", opts.Count))
+
+	// When deduplicating by domain, request extra results to compensate.
+	reqCount := opts.Count
+	if opts.Unique {
+		reqCount = opts.Count * 2
+		if reqCount > 50 {
+			reqCount = 50
+		}
+	}
+	if reqCount > 0 {
+		params.Set("count", fmt.Sprintf("%d", reqCount))
 	} else {
 		params.Set("count", "10")
 	}
@@ -179,9 +189,121 @@ func Search(client *browser.Client, opts SearchOptions) ([]SearchResult, error)
 		})
 	}
 
+	// --unique: title dedup (>80% overlap) + max 3 per domain.
+	if opts.Unique {
+		results = dedupResults(results, opts.Count)
+	}
+
 	return results, nil
 }
 
+// dedupResults applies --unique filtering:
+//  1. Title similarity dedup (>80% character overlap → same content, keep first)
+//  2. Max 3 results per domain
+//
+// Returns at most `limit` results.
+func dedupResults(results []SearchResult, limit int) []SearchResult {
+	if len(results) == 0 {
+		return results
+	}
+
+	// Pass 1: title dedup (highest-ranked first).
+	titleKept := make([]SearchResult, 0, len(results))
+	titleNorms := make([]string, 0, len(results))
+	for _, r := range results {
+		n := normalizeTitle(r.Title)
+		dup := false
+		for _, existing := range titleNorms {
+			if isSimilar(n, existing) {
+				dup = true
+				break
+			}
+		}
+		if !dup {
+			titleNorms = append(titleNorms, n)
+			titleKept = append(titleKept, r)
+		}
+	}
+
+	// Pass 2: per-domain cap of 3 (keep highest-ranked per domain first).
+	domainCount := make(map[string]int)
+	out := make([]SearchResult, 0, limit)
+	for _, r := range titleKept {
+		d := extractDomain(r.Source)
+		if domainCount[d] >= 3 {
+			continue
+		}
+		domainCount[d]++
+		out = append(out, r)
+		if len(out) >= limit {
+			break
+		}
+	}
+	return out
+}
+
+// normalizeTitle strips noise so that near-identical titles compare equal.
+func normalizeTitle(t string) string {
+	s := strings.ToLower(t)
+	// Remove common Chinese/English delimiter characters
+	for _, c := range []string{" ", "-", "_", "|", "：", ":", "【", "】", "《", "》", "（", "）", "(", ")", "[", "]"} {
+		s = strings.ReplaceAll(s, c, "")
+	}
+	return s
+}
+
+// isSimilar returns true when two normalized titles likely represent
+// the same content. Uses character-level containment: if the shorter
+// title is mostly contained within the longer one, they match.
+func isSimilar(a, b string) bool {
+	if a == b {
+		return true
+	}
+	short, long := a, b
+	if len(short) > len(long) {
+		short, long = long, short
+	}
+	if len(short) < 8 {
+		return false // too short to judge, keep both
+	}
+
+	// Count characters from short that appear in long (order-independent).
+	runeCount := make(map[rune]int)
+	for _, r := range long {
+		runeCount[r]++
+	}
+	matched := 0
+	for _, r := range short {
+		if runeCount[r] > 0 {
+			runeCount[r]--
+			matched++
+		}
+	}
+	ratio := float64(matched) / float64(len([]rune(short)))
+
+	// 80%+ character overlap → same content.
+	return ratio >= 0.80
+}
+
+// extractDomain returns the host part from a URL string.
+func extractDomain(raw string) string {
+	if raw == "" {
+		return ""
+	}
+	// Strip protocol if present
+	s := raw
+	if after, ok := strings.CutPrefix(s, "https://"); ok {
+		s = after
+	} else if after, ok := strings.CutPrefix(s, "http://"); ok {
+		s = after
+	}
+	// Return everything before the first slash
+	if idx := strings.IndexByte(s, '/'); idx >= 0 {
+		return s[:idx]
+	}
+	return s
+}
+
 // FormatResults returns a human-readable string for terminal display (stderr).
 func FormatResults(results []SearchResult, query string) string {
 	var sb strings.Builder
diff --git a/bing-cli/cmd/root.go b/bing-cli/cmd/root.go
index 771e01f..8275c28 100644
--- a/bing-cli/cmd/root.go
+++ b/bing-cli/cmd/root.go
@@ -2,10 +2,8 @@ package cmd
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
-	"strings"
 
 	"bing-cli/bing"
 	"bing-cli/browser"
@@ -17,18 +15,11 @@ import (
 var rootCmd = &cobra.Command{
 	Use:   "bing-cli",
 	Short: "Bing search CLI powered by browser automation",
-	Long: `bing-cli automates Bing Search by running inside the user's real browser
-session via kimi-webbridge (http://127.0.0.1:10086). All commands emit JSON on
-stdout: {"ok":true,"data":...} on success, {"ok":false,"error":{...}} on failure.
-Every command exits non-zero on failure.
+	Long: `Bing search CLI using real browser sessions via kimi-webbridge.
+No API key required — results from real Bing pages, avoiding bot detection.
 
-No API key required. Results come from real Bing pages, avoiding bot detection.
-Use --market to switch between Chinese and international results.
-
-Examples:
-  bing-cli search "rust programming"
-  bing-cli search "牛仔裤" --market cn
-  bing-cli search "AI agents" --market us --count 5`,
+Default output is a flat JSON array — designed for agent consumption.
+Use --human (-H) to also print readable text on stderr.`,
 }
 
 func Execute() error {
@@ -36,72 +27,28 @@ func Execute() error {
 }
 
 func init() {
-	// ---- search ----
 	searchCmd := &cobra.Command{
-		Use:   "search <query>",
-		Short: "Search Bing and return structured results",
-		Long: `Navigates to bing.com and extracts the organic result list.
-
-Examples:
-  bing-cli search "claude code"
-  bing-cli search "英格兰 阿根廷 世界杯" --count 5
-  bing-cli search "牛仔裤面料" --market cn --raw
-`,
-		Args: cobra.MinimumNArgs(1),
-		Run:  runSearch,
+		Use:   "search [query]",
+		Short: "Search Bing, returns JSON array to stdout",
+		Args:  cobra.MinimumNArgs(1),
+		Run:   runSearch,
 	}
-	searchCmd.Flags().StringP("market", "m", "", "Market: cn (China), us (International), or empty (auto)")
+	searchCmd.Flags().StringP("market", "m", "us", "Market: us (default, international), cn (China-local)")
 	searchCmd.Flags().IntP("count", "n", 10, "Number of results (max 50)")
 	searchCmd.Flags().IntP("offset", "o", 0, "Result offset for pagination")
-	searchCmd.Flags().BoolP("raw", "r", false, "Output raw JSON array only (for agent consumption)")
-	searchCmd.SilenceUsage = true
-	searchCmd.SilenceErrors = true
-	rootCmd.AddCommand(searchCmd)
-
-	// ---- result ----
-	resultCmd := &cobra.Command{
-		Use:   "result <url>",
-		Short: "Fetch a page and extract title, description, and text",
-		Long: `Navigates to a URL and extracts structured page content.
-
-Examples:
-  bing-cli result "https://example.com/article"
-`,
-		Args: cobra.ExactArgs(1),
-		Run:  runResult,
-	}
-	resultCmd.Flags().BoolP("raw", "r", false, "Output raw JSON only (for agent consumption)")
-	resultCmd.SilenceUsage = true
-	resultCmd.SilenceErrors = true
-	rootCmd.AddCommand(resultCmd)
-}
+	searchCmd.Flags().BoolP("unique", "u", false, "Title dedup (>80% similar) + max 3 per domain")
+	searchCmd.Flags().BoolP("human", "H", false, "Also print human-readable text to stderr")
 
-// daemonCheck verifies kimi-webbridge is reachable and the extension is
-// connected. Exits with a clear diagnostic on failure.
-func daemonCheck(client *browser.Client) {
-	st, err := client.Status()
-	if err != nil {
-		output.Error("daemon_unreachable", err.Error())
-		os.Exit(1)
-	}
-	if !st.Running {
-		output.Error("daemon_not_running",
-			"kimi-webbridge daemon is not running (open the Kimi Desktop App)")
-		os.Exit(1)
-	}
-	if !st.ExtensionConnected {
-		output.Error("extension_not_connected",
-			"Chrome WebBridge extension is not connected (see https://www.kimi.com/features/webbridge)")
-		os.Exit(1)
-	}
+	rootCmd.AddCommand(searchCmd)
 }
 
 func runSearch(cmd *cobra.Command, args []string) {
-	query := strings.Join(args, " ")
+	query := args[0]
 	market, _ := cmd.Flags().GetString("market")
 	count, _ := cmd.Flags().GetInt("count")
 	offset, _ := cmd.Flags().GetInt("offset")
-	raw, _ := cmd.Flags().GetBool("raw")
+	unique, _ := cmd.Flags().GetBool("unique")
+	human, _ := cmd.Flags().GetBool("human")
 
 	if count < 1 {
 		count = 1
@@ -110,69 +57,31 @@ func runSearch(cmd *cobra.Command, args []string) {
 		count = 50
 	}
 
-	client := browser.NewClient("bing-cli")
+	client := browser.NewClient("bing")
 	defer client.Close()
 
-	daemonCheck(client)
-
 	results, err := bing.Search(client, bing.SearchOptions{
 		Query:  query,
 		Market: market,
 		Count:  count,
 		Offset: offset,
+		Unique: unique,
 	})
 	if err != nil {
-		var consentErr bing.ErrConsentRequired
-		if errors.As(err, &consentErr) {
-			output.Error("consent_required", err.Error())
-			os.Exit(1)
-		}
-		if strings.Contains(err.Error(), "daemon unreachable") {
-			output.Error("daemon_unreachable", err.Error())
-			os.Exit(1)
-		}
-		output.Error("search_failed", err.Error())
+		output.Error("search_error", err.Error())
 		os.Exit(1)
 	}
 
-	if results == nil {
-		results = []bing.SearchResult{}
-	}
-
-	if raw {
-		enc := json.NewEncoder(os.Stdout)
-		enc.SetEscapeHTML(false)
-		enc.Encode(results)
-	} else {
-		output.Success(map[string]any{
-			"query":   query,
-			"count":   len(results),
-			"results": results,
-		})
-		fmt.Fprint(os.Stderr, bing.FormatResults(results, query))
-	}
-}
-
-func runResult(cmd *cobra.Command, args []string) {
-	targetURL := args[0]
-	raw, _ := cmd.Flags().GetBool("raw")
-
-	client := browser.NewClient("bing-cli")
-	defer client.Close()
-
-	daemonCheck(client)
-
-	page, err := bing.FetchResult(client, targetURL)
-	if err != nil {
-		output.Error("result_failed", err.Error())
+	// Default: flat JSON array on stdout (optimized for agent consumption)
+	enc := json.NewEncoder(os.Stdout)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(results); err != nil {
+		output.Error("encode_error", err.Error())
 		os.Exit(1)
 	}
 
-	if raw {
-		enc := json.NewEncoder(os.Stdout)
-		enc.SetEscapeHTML(false)
-		enc.Encode(page)
-	} else {
-		output.Success(page)
+	// Optional human-readable output on stderr
+	if human {
+		fmt.Fprint(os.Stderr, "\n"+bing.FormatResults(results, query))
 	}
 }
diff --git a/bing-cli/root.go b/bing-cli/root.go
new file mode 100644
index 0000000..8275c28
--- /dev/null
+++ b/bing-cli/root.go
@@ -0,0 +1,87 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"bing-cli/bing"
+	"bing-cli/browser"
+	"bing-cli/output"
+
+	"github.com/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "bing-cli",
+	Short: "Bing search CLI powered by browser automation",
+	Long: `Bing search CLI using real browser sessions via kimi-webbridge.
+No API key required — results from real Bing pages, avoiding bot detection.
+
+Default output is a flat JSON array — designed for agent consumption.
+Use --human (-H) to also print readable text on stderr.`,
+}
+
+func Execute() error {
+	return rootCmd.Execute()
+}
+
+func init() {
+	searchCmd := &cobra.Command{
+		Use:   "search [query]",
+		Short: "Search Bing, returns JSON array to stdout",
+		Args:  cobra.MinimumNArgs(1),
+		Run:   runSearch,
+	}
+	searchCmd.Flags().StringP("market", "m", "us", "Market: us (default, international), cn (China-local)")
+	searchCmd.Flags().IntP("count", "n", 10, "Number of results (max 50)")
+	searchCmd.Flags().IntP("offset", "o", 0, "Result offset for pagination")
+	searchCmd.Flags().BoolP("unique", "u", false, "Title dedup (>80% similar) + max 3 per domain")
+	searchCmd.Flags().BoolP("human", "H", false, "Also print human-readable text to stderr")
+
+	rootCmd.AddCommand(searchCmd)
+}
+
+func runSearch(cmd *cobra.Command, args []string) {
+	query := args[0]
+	market, _ := cmd.Flags().GetString("market")
+	count, _ := cmd.Flags().GetInt("count")
+	offset, _ := cmd.Flags().GetInt("offset")
+	unique, _ := cmd.Flags().GetBool("unique")
+	human, _ := cmd.Flags().GetBool("human")
+
+	if count < 1 {
+		count = 1
+	}
+	if count > 50 {
+		count = 50
+	}
+
+	client := browser.NewClient("bing")
+	defer client.Close()
+
+	results, err := bing.Search(client, bing.SearchOptions{
+		Query:  query,
+		Market: market,
+		Count:  count,
+		Offset: offset,
+		Unique: unique,
+	})
+	if err != nil {
+		output.Error("search_error", err.Error())
+		os.Exit(1)
+	}
+
+	// Default: flat JSON array on stdout (optimized for agent consumption)
+	enc := json.NewEncoder(os.Stdout)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(results); err != nil {
+		output.Error("encode_error", err.Error())
+		os.Exit(1)
+	}
+
+	// Optional human-readable output on stderr
+	if human {
+		fmt.Fprint(os.Stderr, "\n"+bing.FormatResults(results, query))
+	}
+}
diff --git a/bing-cli/search.go b/bing-cli/search.go
new file mode 100644
index 0000000..43e226a
--- /dev/null
+++ b/bing-cli/search.go
@@ -0,0 +1,328 @@
+package bing
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"time"
+
+	"bing-cli/browser"
+)
+
+const baseURL = "https://www.bing.com/search"
+
+// ErrConsentRequired is returned when Bing serves a consent/privacy
+// interstitial. The user must accept it once in Chrome, then retry.
+type ErrConsentRequired struct{}
+
+func (e ErrConsentRequired) Error() string {
+	return "Bing served a consent interstitial. Accept once in Chrome, then retry."
+}
+
+// bingRedirectRe matches the real target URL embedded in Bing's /ck/a redirect page.
+var bingRedirectRe = regexp.MustCompile(`https?://[a-zA-Z0-9][a-zA-Z0-9._/-]*[a-zA-Z0-9/]`)
+
+// SearchResult is one item in the Bing search result list.
+type SearchResult struct {
+	Title   string `json:"title"`
+	URL     string `json:"url"`
+	Snippet string `json:"snippet"`
+	Source  string `json:"source"`
+}
+
+// SearchOptions bundles all search parameters.
+type SearchOptions struct {
+	Query  string
+	Market string // "cn", "us", "" (auto)
+	Count  int
+	Offset int
+	Unique bool // title dedup (>80% overlap) + max 3 per domain
+}
+
+// searchExtractJS is the merged extractor:
+//   - Async polling (8 s deadline) — google-cli pattern
+//   - Consent interstitial detection — google-cli pattern
+//   - Bing selectors (#b_results > li.b_algo) — v2
+//   - bingHref capture for /ck/a redirect resolution — acc
+//   - URL dedup — google-cli pattern
+//   - Snippet cleaning (whitespace + trailing "Read more") — both
+const searchExtractJS = `(async () => {
+  const deadline = Date.now() + 8000;
+  let results = [];
+
+  while (Date.now() < deadline) {
+    if (location.host.startsWith('consent.')) {
+      return JSON.stringify({consent: true, items: []});
+    }
+
+    const items = document.querySelectorAll("#b_results > li.b_algo");
+    if (items.length > 0) {
+      const seen = new Set();
+      results = Array.from(items).map(el => {
+        const h2 = el.querySelector("h2 a");
+        const cite = el.querySelector(".b_attribution cite, cite");
+        const p = el.querySelector(".b_caption p");
+        if (!h2) return null;
+        const displayURL = cite ? cite.textContent.trim() : "";
+        if (!displayURL || seen.has(displayURL)) return null;
+        seen.add(displayURL);
+        return {
+          title:    h2.textContent.trim(),
+          url:      displayURL,
+          snippet:  (p ? p.textContent.trim().replace(/\s+/g, " ") : "")
+                      .replace(/\s*Read more\.?$/, "")
+                      .slice(0, 300),
+          source:   cite ? cite.textContent.trim() : "",
+          bingHref: h2.getAttribute("href") || ""
+        };
+      }).filter(Boolean);
+      if (results.length > 0) break;
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  return JSON.stringify({consent: false, items: results});
+})()`
+
+// resolveBingURL follows Bing's /ck/a redirect and extracts the real target
+// URL from the HTML response body. Falls back to the original URL on failure.
+func resolveBingURL(bingURL string) string {
+	if !strings.Contains(bingURL, "/ck/a") || !strings.Contains(bingURL, "u=") {
+		return bingURL
+	}
+	client := &http.Client{Timeout: 8 * time.Second}
+	resp, err := client.Get(bingURL)
+	if err != nil {
+		return bingURL
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return bingURL
+	}
+	body, _ := io.ReadAll(resp.Body)
+	matches := bingRedirectRe.FindAllString(string(body), -1)
+	for _, m := range matches {
+		if !strings.Contains(m, "bing.com/ck") {
+			return m
+		}
+	}
+	return bingURL
+}
+
+// Search navigates to the Bing SERP and extracts organic results.
+func Search(client *browser.Client, opts SearchOptions) ([]SearchResult, error) {
+	params := url.Values{}
+	params.Set("q", opts.Query)
+
+	// When deduplicating by domain, request extra results to compensate.
+	reqCount := opts.Count
+	if opts.Unique {
+		reqCount = opts.Count * 2
+		if reqCount > 50 {
+			reqCount = 50
+		}
+	}
+	if reqCount > 0 {
+		params.Set("count", fmt.Sprintf("%d", reqCount))
+	} else {
+		params.Set("count", "10")
+	}
+	if opts.Offset > 0 {
+		params.Set("offset", fmt.Sprintf("%d", opts.Offset))
+	}
+	if opts.Market != "" {
+		switch opts.Market {
+		case "cn", "zh-CN", "zh":
+			params.Set("cc", "cn")
+			params.Set("setlang", "zh-Hans")
+		case "us", "en-US", "en":
+			params.Set("cc", "us")
+			params.Set("setlang", "en")
+		default:
+			params.Set("cc", opts.Market)
+		}
+	}
+
+	searchURL := baseURL + "?" + params.Encode()
+
+	if err := client.Navigate(searchURL); err != nil {
+		return nil, fmt.Errorf("navigate: %w", err)
+	}
+
+	// Extract results with CDP retry.
+	var rawPayload struct {
+		Consent bool `json:"consent"`
+		Items   []struct {
+			Title    string `json:"title"`
+			URL      string `json:"url"`
+			Snippet  string `json:"snippet"`
+			Source   string `json:"source"`
+			BingHref string `json:"bingHref"`
+		} `json:"items"`
+	}
+
+	if err := evaluateWithRetry(client, searchExtractJS, &rawPayload); err != nil {
+		return nil, fmt.Errorf("extract: %w", err)
+	}
+
+	if rawPayload.Consent {
+		return nil, ErrConsentRequired{}
+	}
+
+	results := make([]SearchResult, 0, len(rawPayload.Items))
+	for _, item := range rawPayload.Items {
+		finalURL := item.URL
+		// Resolve Bing's encrypted /ck/a redirect to the real URL.
+		if item.BingHref != "" && strings.Contains(item.BingHref, "/ck/a") {
+			if resolved := resolveBingURL(item.BingHref); resolved != item.BingHref {
+				finalURL = resolved
+			}
+		}
+		results = append(results, SearchResult{
+			Title:   item.Title,
+			URL:     finalURL,
+			Snippet: item.Snippet,
+			Source:  item.Source,
+		})
+	}
+
+	// --unique: title dedup (>80% overlap) + max 3 per domain.
+	if opts.Unique {
+		results = dedupResults(results, opts.Count)
+	}
+
+	return results, nil
+}
+
+// dedupResults applies --unique filtering:
+//  1. Title similarity dedup (>80% character overlap → same content, keep first)
+//  2. Max 3 results per domain
+//
+// Returns at most `limit` results.
+func dedupResults(results []SearchResult, limit int) []SearchResult {
+	if len(results) == 0 {
+		return results
+	}
+
+	// Pass 1: title dedup (highest-ranked first).
+	titleKept := make([]SearchResult, 0, len(results))
+	titleNorms := make([]string, 0, len(results))
+	for _, r := range results {
+		n := normalizeTitle(r.Title)
+		dup := false
+		for _, existing := range titleNorms {
+			if isSimilar(n, existing) {
+				dup = true
+				break
+			}
+		}
+		if !dup {
+			titleNorms = append(titleNorms, n)
+			titleKept = append(titleKept, r)
+		}
+	}
+
+	// Pass 2: per-domain cap of 3 (keep highest-ranked per domain first).
+	domainCount := make(map[string]int)
+	out := make([]SearchResult, 0, limit)
+	for _, r := range titleKept {
+		d := extractDomain(r.Source)
+		if domainCount[d] >= 3 {
+			continue
+		}
+		domainCount[d]++
+		out = append(out, r)
+		if len(out) >= limit {
+			break
+		}
+	}
+	return out
+}
+
+// normalizeTitle strips noise so that near-identical titles compare equal.
+func normalizeTitle(t string) string {
+	s := strings.ToLower(t)
+	// Remove common Chinese/English delimiter characters
+	for _, c := range []string{" ", "-", "_", "|", "：", ":", "【", "】", "《", "》", "（", "）", "(", ")", "[", "]"} {
+		s = strings.ReplaceAll(s, c, "")
+	}
+	return s
+}
+
+// isSimilar returns true when two normalized titles likely represent
+// the same content. Uses character-level containment: if the shorter
+// title is mostly contained within the longer one, they match.
+func isSimilar(a, b string) bool {
+	if a == b {
+		return true
+	}
+	short, long := a, b
+	if len(short) > len(long) {
+		short, long = long, short
+	}
+	if len(short) < 8 {
+		return false // too short to judge, keep both
+	}
+
+	// Count characters from short that appear in long (order-independent).
+	runeCount := make(map[rune]int)
+	for _, r := range long {
+		runeCount[r]++
+	}
+	matched := 0
+	for _, r := range short {
+		if runeCount[r] > 0 {
+			runeCount[r]--
+			matched++
+		}
+	}
+	ratio := float64(matched) / float64(len([]rune(short)))
+
+	// 80%+ character overlap → same content.
+	return ratio >= 0.80
+}
+
+// extractDomain returns the host part from a URL string.
+func extractDomain(raw string) string {
+	if raw == "" {
+		return ""
+	}
+	// Strip protocol if present
+	s := raw
+	if after, ok := strings.CutPrefix(s, "https://"); ok {
+		s = after
+	} else if after, ok := strings.CutPrefix(s, "http://"); ok {
+		s = after
+	}
+	// Return everything before the first slash
+	if idx := strings.IndexByte(s, '/'); idx >= 0 {
+		return s[:idx]
+	}
+	return s
+}
+
+// FormatResults returns a human-readable string for terminal display (stderr).
+func FormatResults(results []SearchResult, query string) string {
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("Bing Search: %s\n", query))
+	sb.WriteString(strings.Repeat("─", 80) + "\n")
+	for i, r := range results {
+		sb.WriteString(fmt.Sprintf("\n%d. %s\n", i+1, r.Title))
+		sb.WriteString(fmt.Sprintf("   %s\n", r.URL))
+		if r.Snippet != "" {
+			sb.WriteString(fmt.Sprintf("   %s\n", truncate(r.Snippet, 200)))
+		}
+	}
+	return sb.String()
+}
+
+func truncate(s string, n int) string {
+	runes := []rune(s)
+	if len(runes) <= n {
+		return s
+	}
+	return string(runes[:n]) + "…"
+}