dsh-free-search 0.8.6 → 0.8.7

package/lib/client.js

@@ -51,6 +51,13 @@ window.__ModuleLoader__.load({
       ".dshfs-select{color-scheme:light dark}",
       ".dshfs-select option, .dshfs-select optgroup{background-color:#ffffff;color:#1d1d1f}",
       "@media (prefers-color-scheme: dark){.dshfs-select{color-scheme:dark}.dshfs-select option, .dshfs-select optgroup{background-color:#1e1f24;color:#f5f5f7}}",
+      ".dshfs-textarea{border:1px solid rgba(0,0,0,.1);font:inherit;font-variant-numeric:tabular-nums;color:inherit;background:rgba(0,0,0,.03);border-radius:10px;padding:8px 12px;min-height:96px;height:auto;font-size:14px;line-height:1.5;transition:all 160ms cubic-bezier(.4,0,.2,1);width:100%;box-sizing:border-box;resize:vertical;font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,\"Liberation Mono\",monospace}",
+      "@media (prefers-color-scheme: dark){.dshfs-textarea{border:1px solid rgba(255,255,255,.1);background:rgba(255,255,255,.05)}}",
+      ".dshfs-textarea:hover:not(:disabled){border-color:rgba(0,0,0,.2);background:rgba(0,0,0,.05)}",
+      "@media (prefers-color-scheme: dark){.dshfs-textarea:hover:not(:disabled){border-color:rgba(255,255,255,.2);background:rgba(255,255,255,.08)}}",
+      ".dshfs-textarea:focus-visible{outline:none;border-color:#0071e3;box-shadow:0 0 0 3px rgba(0,113,227,.25);background:#ffffff}",
+      "@media (prefers-color-scheme: dark){.dshfs-textarea:focus-visible{border-color:#0a84ff;box-shadow:0 0 0 3px rgba(10,132,255,.25);background:#1c1c1e}}",
+      ".dshfs-textarea:disabled{opacity:.5;cursor:default}",
       ".dshfs-ttl{width:100px}",
       ".dshfs-fieldRow{display:flex;align-items:center;gap:12px;flex-wrap:wrap}",
       ".dshfs-keyStorage{width:auto;min-width:200px}",
@@ -60,7 +67,7 @@ window.__ModuleLoader__.load({
       ".dshfs-platform{display:flex;align-items:center;gap:6px;color:inherit;font-size:14px;cursor:pointer}",
       ".dshfs-platform input{accent-color:#0071e3;width:16px;height:16px}",
       ".dshfs-priorityList{display:flex;flex-direction:column;gap:6px}",
-      ".dshfs-priorityRow{display:flex;align-items:center;gap:8px;padding:6px 8px;border:1px solid rgba(0,0,0,.08);border-radius:10px;background:rgba(0,0,0,.02)}",
+      ".dshfs-priorityRow{display:flex;align-items:center;gap:8px;padding:6px 8px;border:1px solid rgba(0,0,0,.08);border-radius:10px;background:rgba(0,0,0,.02);box-sizing:border-box;min-height:42px}",
       "@media (prefers-color-scheme: dark){.dshfs-priorityRow{border-color:rgba(255,255,255,.09);background:rgba(255,255,255,.035)}}",
       ".dshfs-priorityRowDisabled{opacity:.58}",
       ".dshfs-priorityIndex{width:26px;flex:none;color:#6e6e73;font-size:12px;font-variant-numeric:tabular-nums;text-align:right}",
@@ -204,6 +211,9 @@ window.__ModuleLoader__.load({
         platformHint: "为 agent 的 platform_search 工具启用平台。禁用的平台会被跳过。",
         cacheTtl: "结果缓存时长（分钟）",
         cacheTtlHint: "0 关闭缓存，最长 5 分钟。缩短可加快时效，延长可防限流、省额度。",
+        blockedDomainsLabel: "域名黑名单（blockedDomains）",
+        blockedDomainsHint: "一行一个域名，命中的站点及其所有子域都会从搜索结果里剔除（csdn.net 覆盖 blog.csdn.net）。留空＝不过滤。可以直接粘贴完整网址，scheme、路径和端口会被自动去掉。",
+        blockedDomainsWarn: (corrected, dupes, dropped) => `已忽略 ${dupes} 个重复项、${dropped} 行无法识别；${corrected} 行已自动修正为裸域名。规则对下一次搜索生效，旧结果缓存会同步失效。`,
         unavailable: "设置不可用 —— free-search 桥接未暴露。",
         saveFailed: "保存失败",
         saveFailedDetail: (d) => `保存失败：${d}`,
@@ -310,6 +320,9 @@ window.__ModuleLoader__.load({
         platformHint: "Enable platforms for the agent's platform_search tool. Disabled platforms are skipped.",
         cacheTtl: "Result cache TTL (minutes)",
         cacheTtlHint: "0 disables caching, max 5 minutes. Lower = fresher results, higher = less rate-limiting / fewer credits used.",
+        blockedDomainsLabel: "Domain blocklist (blockedDomains)",
+        blockedDomainsHint: "One domain per line. A matched site and all of its subdomains are dropped from search results (csdn.net covers blog.csdn.net). Leave empty to disable. Full URLs are accepted — scheme, path and port are stripped automatically.",
+        blockedDomainsWarn: (corrected, dupes, dropped) => `Ignored ${dupes} duplicate(s) and ${dropped} unrecognized line(s); corrected ${corrected} line(s) to bare domains. Rules apply to the next search, and the result cache is invalidated accordingly.`,
         unavailable: "Settings unavailable — the free-search bridge is not exposed.",
         saveFailed: "save failed",
         saveFailedDetail: (d) => `save failed: ${d}`,
@@ -414,6 +427,45 @@ window.__ModuleLoader__.load({
       if (!Array.isArray(value)) return FAILURE_CLASSES.map((cls) => cls.id);
       return [...new Set(value.filter((id) => FAILURE_CLASSES.some((cls) => cls.id === id)))];
     };
+    // 域名黑名单：本地解析（显示 + 保存）。
+    // 注意：清洗规则必须与 lib/domain_filter.js 的 normalizeDomainList 保持一致——
+    // 服务端也会规范化一次（用户可直接编辑 YAML 绕过 UI），两边结果相同才不会有"存进去对、读回来错"。
+    // 这里额外返回统计量，用于字段下方的非阻断提示。
+    const parseBlockedDomains = (text) => {
+      const lines = String(text ?? "")
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+      const stats = { corrected: 0, dupes: 0, dropped: 0 };
+      const seen = new Set();
+      const domains = [];
+      for (const line of lines) {
+        let s = line.toLowerCase();
+        const before = s;
+        s = s.replace(/^[a-z][a-z0-9+.-]*:\/\//, "");
+        const cut = s.search(/[/?#]/);
+        if (cut >= 0) s = s.slice(0, cut);
+        if (!s) {
+          stats.dropped++;
+          continue;
+        }
+        const colon = s.lastIndexOf(":");
+        if (colon >= 0 && /^\d+$/.test(s.slice(colon + 1))) s = s.slice(0, colon);
+        s = s.replace(/^www\./, "").replace(/\.+$/, "");
+        if (!s || !/^[a-z0-9][a-z0-9.-]*$/.test(s) || s.startsWith(".")) {
+          stats.dropped++;
+          continue;
+        }
+        if (before !== s) stats.corrected++;
+        if (seen.has(s)) {
+          stats.dupes++;
+          continue;
+        }
+        seen.add(s);
+        domains.push(s);
+      }
+      return { domains, stats };
+    };
 
     async function bridgeDescribe() {
       const response = await fetch(`${BRIDGE_PREFIX}/describe`, {
@@ -520,6 +572,7 @@ window.__ModuleLoader__.load({
       const [zhPool, setZhPool] = react.useState(DEFAULT_ZH_POOL);
       const [enPool, setEnPool] = react.useState(DEFAULT_EN_POOL);
       const [fallbackOn, setFallbackOn] = react.useState(FAILURE_CLASSES.map((cls) => cls.id));
+      const [blockedDomains, setBlockedDomains] = react.useState("");
       const [safeSearch, setSafeSearch] = react.useState("off");
       const [bingMarket, setBingMarket] = react.useState("zh-CN");
       const [anysearchKey, setAnysearchKey] = react.useState("");
@@ -624,6 +677,8 @@ window.__ModuleLoader__.load({
               setZhPool(normalizePoolIds(v.zhPool, DEFAULT_ZH_POOL));
               setEnPool(normalizePoolIds(v.enPool, DEFAULT_EN_POOL));
               setFallbackOn(normalizeFallbackOn(v.fallbackOn));
+      // 黑名单以文本形式回显（一行一个）；配置里存的是数组
+      setBlockedDomains((Array.isArray(v.blockedDomains) ? v.blockedDomains : []).join("\n"));
               setSafeSearch(v.safeSearch === "strict" || v.safeSearch === "moderate" ? v.safeSearch : "off");
               setBingMarket(v.bingMarket === undefined ? "zh-CN" : v.bingMarket);
               setLang(v.lang === "en" ? "en" : "zh");
@@ -763,6 +818,7 @@ window.__ModuleLoader__.load({
           ops.push({ op: "set", path: ["zhPool"], value: normalizePoolIds(zhPool, DEFAULT_ZH_POOL) });
           ops.push({ op: "set", path: ["enPool"], value: normalizePoolIds(enPool, DEFAULT_EN_POOL) });
           ops.push({ op: "set", path: ["fallbackOn"], value: normalizeFallbackOn(fallbackOn) });
+      ops.push({ op: "set", path: ["blockedDomains"], value: parseBlockedDomains(blockedDomains).domains });
           ops.push({ op: "set", path: ["lang"], value: lang });
           ops.push({ op: "set", path: ["keyStorage"], value: keyStorage });
           ops.push({ op: "set", path: ["safeSearch"], value: safeSearch });
@@ -1340,6 +1396,42 @@ react_jsx_runtime.jsx("div", {
                       }),
                     ],
                   }),
+                  react_jsx_runtime.jsx("div", {
+                    className: "dshfs-field",
+                    children: [
+                      react_jsx_runtime.jsx("div", {
+                        className: "dshfs-label",
+                        children: t.blockedDomainsLabel,
+                      }),
+                      react_jsx_runtime.jsx("textarea", {
+                        className: "dshfs-textarea",
+                        rows: 5,
+                        placeholder: "csdn.net\n51cto.com",
+                        value: blockedDomains,
+                        spellCheck: false,
+                        disabled: !ready || saving,
+                        onChange: (e) => {
+                          setBlockedDomains(e.target.value);
+                          setDirty(true);
+                          setFailed(false);
+                          setSaveError("");
+                        },
+                      }),
+                      react_jsx_runtime.jsx("p", {
+                        className: "dshfs-hint",
+                        children: t.blockedDomainsHint,
+                      }),
+                      (() => {
+                        // 轻量提示：从不阻断保存，只告诉用户哪些行被自动处理了
+                        const { stats } = parseBlockedDomains(blockedDomains);
+                        if (stats.corrected === 0 && stats.dupes === 0 && stats.dropped === 0) return null;
+                        return react_jsx_runtime.jsx("p", {
+                          className: "dshfs-hint",
+                          children: t.blockedDomainsWarn(stats.corrected, stats.dupes, stats.dropped),
+                        });
+                      })(),
+                    ],
+                  }),
                   react_jsx_runtime.jsx("div", {
                     className: "dshfs-field",
                     children: [

package/lib/domain_filter.js

@@ -0,0 +1,100 @@
+// #72 域名黑名单：在结果进入上下文前过滤内容农场（CSDN 等）。
+// 匹配语义（issue #72 约定）：
+//   - 域名相等或其子域命中（csdn.net 覆盖 blog.csdn.net）
+//   - 忽略大小写；www. 前缀归一；无 scheme / 无路径；
+//   - 不做正则（notcsdn.net 不得被 csdn.net 命中）
+// 生效方式：provider.search 入口按当次请求的 blockedDomains 设置"活动黑名单"，
+// uniqueSources 在收敛（去重 + limit）之前过滤——被屏蔽条目让位给后续候选，
+// 因此 maxResults 仍能填满，且 truncated 只在真正触及上限时为 true。
+
+let active = [];
+/**
+ * 配置清洗：把用户随手填的域名/URL 归一成裸域名规则。
+ * 处理 trim、scheme、路径/query/hash、端口、www.、大小写、去重（保序）、丢弃空值与非法行。
+ *
+ * 为什么要服务端兜底：blockedDomains 是 .volatile() 配置，用户可以直接编辑 YAML 绕过 UI，
+ * 所以规范化必须在 setActiveBlockedDomains 里做，而不是只做在设置页。
+ * isDomainBlocked 的匹配语义不受影响——规则只是被清洗成更可靠的等价形式。
+ */
+export function normalizeDomainList(list) {
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  const seen = new Set();
+  for (const raw of list) {
+    let s = String(raw ?? "").trim().toLowerCase();
+    if (!s) continue;
+    // 去 scheme（http:// https:// 或其它的 protocol://）
+    s = s.replace(/^[a-z][a-z0-9+.-]*:\/\//, "");
+    // 去路径 / query / hash
+    const cut = s.search(/[/?#]/);
+    if (cut >= 0) s = s.slice(0, cut);
+    if (!s) continue;
+    // 去端口（仅当冒号后是纯数字）
+    const colon = s.lastIndexOf(":");
+    if (colon >= 0 && /^\d+$/.test(s.slice(colon + 1))) s = s.slice(0, colon);
+    // 去 www. 前缀与尾随点号
+    s = s.replace(/^www\./, "").replace(/\.+$/, "");
+    // 只接受"看起来像域名"的行：空格、下划线、中文等直接丢弃（它们永远匹配不到 host）
+    if (!s || !/^[a-z0-9][a-z0-9.-]*$/.test(s) || s.startsWith(".")) continue;
+    if (seen.has(s)) continue;
+    seen.add(s);
+    out.push(s);
+  }
+  return out;
+}
+
+/** 设置本次搜索生效的黑名单（provider.search / research 入口调用）。空数组 = 不过滤。 */
+export function setActiveBlockedDomains(list) {
+  active = normalizeDomainList(list);
+}
+export function getActiveBlockedDomains() {
+  return [...active];
+}
+
+function normalizeHost(host) {
+  return String(host ?? "").toLowerCase().trim().replace(/^www\./, "");
+}
+function normalizeRule(domain) {
+  return String(domain ?? "").toLowerCase().trim().replace(/^www\./, "").replace(/\/+$/, "");
+}
+
+/** 单个 URL 是否命中黑名单；URL 无法解析时返回 false（不误伤）。 */
+export function isDomainBlocked(url, blocked = active) {
+  if (!blocked || blocked.length === 0) return false;
+  let host;
+  try {
+    host = normalizeHost(new URL(String(url)).hostname);
+  } catch {
+    return false;
+  }
+  if (!host) return false;
+  return blocked.some((raw) => {
+    const rule = normalizeRule(raw);
+    if (!rule) return false;
+    return host === rule || host.endsWith("." + rule);
+  });
+}
+
+/** 列表过滤：结果条目统一为 { url } 形态，命中黑名的整条丢弃（保持原顺序=让位语义）。 */
+export function filterBlockedDomains(items, blocked = active) {
+  if (!blocked || blocked.length === 0) return items;
+  return items.filter((item) => !isDomainBlocked(item?.url, blocked));
+}
+
+/**
+ * 结果级收口：引擎返回的 { sources } 在交给上层（provider 返回值 / multi 合并 /
+ * runEngineTest / 工具 execute）之前统一过滤。
+ *
+ * 为什么需要它：uniqueSources 只是 40+ 个引擎里 29 个的"收敛去重"helper，
+ * searchAnysearch / searchPlatform 等 11 个引擎并不经过它（各自直接 return sources）。
+ * 只在 uniqueSources 里过滤会漏掉这些引擎——#72 首版就是这么漏的。
+ * 因此过滤必须落在"结果离开引擎"的所有咽喉点上，而不是某一个 helper 里。
+ *
+ * 无黑名单 / 无命中时原样返回（零分配），调用方可以直接重新赋值。
+ */
+export function applyBlockedFilterToResult(result) {
+  if (!result || !Array.isArray(result.sources)) return result;
+  const sources = filterBlockedDomains(result.sources);
+  if (sources.length === result.sources.length) return result;
+  return { ...result, sources };
+}

package/lib/index.js

@@ -10,6 +10,7 @@ import { registerResearchTool } from "./research.js";
 import { registerDomainSearchTool } from "./vertical.js";
 import { createFetchProvider } from "./fetch_provider.js";
 import { fetchWeather, sanitizeWeatherResult, WEATHER_OUTPUT_SCHEMA } from "./weather.js";
+import { setActiveBlockedDomains, getActiveBlockedDomains, isDomainBlocked, applyBlockedFilterToResult } from "./domain_filter.js";
 
 // 兼容 guard（#55）：Node 会优先解析插件目录下的嵌套依赖，若那里残留旧的
 // @deepseek-ai/schemastery（如 node_modules/dsh-free-search/node_modules/... -> 3.18.1），
@@ -361,10 +362,12 @@ const CACHE_MAX_ENTRIES = 50;
 // fallback 条目（实际引擎 ≠ 首选引擎时）TTL = 配置 TTL 的 1/5（默认 5 分钟 → 60s）：
 // 首选引擎恢复后最多 1 分钟即可拿到新结果，避免回退结果被完整 TTL 钉死；首选成功条目仍用完整 TTL。
 
-function buildCacheKey(query, maxResults, timeRangeLabel, preferred, disabledEngines = [], fallbackOrder = []) {
+function buildCacheKey(query, maxResults, timeRangeLabel, preferred, disabledEngines = [], fallbackOrder = [], blockedDomains = []) {
   const disabledKey = normalizeDisabledEngines(disabledEngines).slice().sort().join(",");
   const orderKey = normalizeFallbackOrder(fallbackOrder).join(",");
-  return [query ?? "", maxResults ?? 5, timeRangeLabel ?? "", preferred, disabledKey, orderKey].join("\u0000");
+  // #72：黑名单参与 key——改动 blockedDomains 后旧缓存自然失效，不会 5 分钟内仍命中旧结果
+  const blockedKey = (Array.isArray(blockedDomains) ? blockedDomains : []).map((d) => String(d).toLowerCase().trim().replace(/^www\./, "")).slice().sort().join(",");
+  return [query ?? "", maxResults ?? 5, timeRangeLabel ?? "", preferred, disabledKey, orderKey, blockedKey].join("\u0000");
 }
 //#endregion
 
@@ -425,10 +428,14 @@ function extractDdgUrl(rel) {
   return rel;
 }
 
+// #72：收敛前过滤域名黑名单——先剔除被屏蔽条目，再去重 + 截断，
+// 因此后面的候选会自动补位（用户得到的是"满员的好结果"，而不是变短的结果）。
 function uniqueSources(sources, limit) {
+  const blocked = getActiveBlockedDomains();
+  const kept = blocked.length ? sources.filter((s) => !isDomainBlocked(s.url, blocked)) : sources;
   const seen = new Set();
   const out = [];
-  for (const s of sources) {
+  for (const s of kept) {
     if (s.url && !seen.has(s.url)) {
       seen.add(s.url);
       out.push(s);
@@ -3073,6 +3080,8 @@ const Config = z.object({
   disabledEngines: z.array(z.string()).default([]).volatile(),
   fallbackOrder: z.array(z.string()).default([]).volatile(),
   fallbackOn: z.array(z.string()).default(DEFAULT_FALLBACK_ON).volatile(),
+  // #72 域名黑名单（默认空=不过滤；子域匹配；provider.search 入口置活动值，uniqueSources 收敛前过滤）
+  blockedDomains: z.array(z.string()).default([]).volatile(),
   cache: z.boolean().default(true).volatile(), // 单 query 结果缓存开关（防限流/省额度）
   cacheTtl: z.number().default(5).volatile(), // 缓存时长（分钟），0-5 可配置（使用处再 clamp）
   keyStorage: z.string().default("credentials").volatile(), // key 存储位置：credentials（凭据中心）| settings（设置页）
@@ -3320,6 +3329,8 @@ function apply(ctx, config) {
         throw new Error("query is required");
       }
       const cfg = current();
+      // #72：本次请求生效的域名黑名单（模块级活动值；各结果咽喉点过滤读取它）
+      setActiveBlockedDomains(cfg.blockedDomains);
       const disabledEngines = normalizeDisabledEngines(cfg.disabledEngines);
       const fallbackOnSet = new Set(normalizeFallbackOn(cfg.fallbackOn));
       const disabledSet = new Set(disabledEngines);
@@ -3340,7 +3351,7 @@ function apply(ctx, config) {
       const cacheTtlMs = (Math.min(Math.max(Number(cfg.cacheTtl) ?? 5, 0), 5)) * 60 * 1000;
       const cacheEnabled = cfg.cache !== false && cacheTtlMs > 0;
       const cacheKey = cacheEnabled
-        ? buildCacheKey(request.query, request.maxResults, timeRangeLabel, preferred, disabledEngines, fallbackOrder)
+        ? buildCacheKey(request.query, request.maxResults, timeRangeLabel, preferred, disabledEngines, fallbackOrder, cfg.blockedDomains)
         : null;
       if (cacheKey !== null) {
         const hit = searchCache.get(cacheKey);
@@ -3348,7 +3359,8 @@ function apply(ctx, config) {
           if (signal?.aborted) throw new Error("search aborted");
           searchCache.delete(cacheKey);
           searchCache.set(cacheKey, hit);
-          return { ...hit.value, sources: hit.value.sources?.slice(), _cache: "hit" };
+          // #72：缓存命中同样过一遍黑名单——首版修复前写入的缓存里可能残留屏蔽域名
+          return { ...applyBlockedFilterToResult({ ...hit.value, sources: hit.value.sources?.slice() }), _cache: "hit" };
         }
         if (hit) searchCache.delete(cacheKey);
       }
@@ -3625,6 +3637,12 @@ function apply(ctx, config) {
             continue;
           }
 
+          if (result.sources.length > 0) {
+            // #72 结果级收口：无论走哪个引擎（其中 11 个不经过 uniqueSources），
+            // 在写缓存与返回之前统一按黑名单过滤；全被屏蔽时视为该引擎 0 结果，继续下一个引擎。
+            result = applyBlockedFilterToResult(result);
+          }
+
           if (result.sources.length > 0) {
             usedEngine = engine;
             clearCooldown(engine);
@@ -3794,6 +3812,9 @@ function apply(ctx, config) {
   // 测试工具：让 agent 逐个测试所有搜索引擎，报告可用性
   const runEngineTest = async (engine, query, timeRange, maxResults = 2) => {
     const cfg = current();
+    // #72：runEngineTest 也被 multi_search 工具 / 设置页 bridge 直接调用，
+    // 不经过 provider.search，所以这里必须自行设置活动黑名单
+    setActiveBlockedDomains(cfg.blockedDomains);
     const q = query || "DeepSeek Harness";
     const n = Math.min(Math.max(Number(maxResults) || 2, 1), 20);
     const tr = parseTimeRange(timeRange);
@@ -3928,7 +3949,8 @@ function apply(ctx, config) {
       }
       return {
         ok: true,
-        sources: (result.sources ?? []).map((s) =>
+        // #72：成功结果出引擎前统一过滤，覆盖不经过 uniqueSources 的 11 个引擎
+        sources: applyBlockedFilterToResult({ sources: result.sources ?? [] }).sources.map((s) =>
           s.snippet ? { ...s, snippet: cleanSnippet(s.snippet, snippetCap(engine)) } : s
         ),
         truncated: result.truncated ?? false,
@@ -3942,6 +3964,8 @@ function apply(ctx, config) {
 
   runMultiSearch = async ({ query, maxResults, engines, timeRange } = {}) => {
     if (!query || !String(query).trim()) throw new Error("query is required");
+    // #72：multi_search 工具直连本函数、不经过 provider.search，自行设置活动黑名单
+    setActiveBlockedDomains(current().blockedDomains);
     const q = String(query).trim();
     const limit = Math.min(Math.max(Number(maxResults) || 8, 1), 20);
     const disabled = new Set(normalizeDisabledEngines(current().disabledEngines));
@@ -4006,8 +4030,13 @@ function apply(ctx, config) {
 
     const urlMap = new Map();
     let itemSeq = 0;
+    // #72：合并前过滤——引擎里未被 uniqueSources 覆盖的结果（如 anysearch）也在这里被挡住
+    const blockedRaw = getActiveBlockedDomains();
     for (const { engine, sources } of rawResults) {
-      for (const source of sources) {
+      const keptSources = blockedRaw.length
+        ? sources.filter((s) => !isDomainBlocked(s?.url, blockedRaw))
+        : sources;
+      for (const source of keptSources) {
         if (!source || !source.url) continue;
         let normUrl = String(source.url).trim();
         try {
@@ -4269,7 +4298,8 @@ function apply(ctx, config) {
               }
             }
             // lossless JSON 不允许 undefined 字段：剔除缺失字段
-            const sources = (result.sources ?? []).map((s) => {
+            // #72：platform_search 直连 searchPlatform（不经 provider.search/runEngineTest），在此收口过滤
+            const sources = applyBlockedFilterToResult({ sources: result.sources ?? [] }).sources.map((s) => {
               const source = {};
               if (s.url !== undefined && s.url !== null && s.url !== "") source.url = s.url;
               if (s.title !== undefined && s.title !== null && s.title !== "") source.title = String(s.title);

package/lib/research.js

@@ -7,6 +7,7 @@ import { defineTool } from "@deepseek-ai/dsh-tools";
 import { getFresh, put as cachePut, search as cacheSearch } from "./cache.js";
 import { rerank, embed, cosineMatrix, decide, judgeQueryIntent } from "./rerank.js";
 import { httpsJson, htmlToText, callExa, callFirecrawl, callCrawl4ai } from "./fetch_upstream.js";
+import { isDomainBlocked } from "./domain_filter.js";
 
 // 模型组件的受控替身（测试/评审用；抓取层的替身在 fetch_upstream.js 的 CONTROLLED_STUBS）
 export const CONTROLLED_STUBS = { rerank: null, embed: null, decide: null, judgeQueryIntent: null };
@@ -227,6 +228,8 @@ export function buildClusters(sources) {
   let clusterSeq = 0;
   for (const s of sources) {
     if (!s || typeof s.url !== "string") continue;
+    // #72：黑名单域在候选构建阶段就剔除——items / 簇 / 正文三层都不会再出现它
+    if (isDomainBlocked(s.url)) continue;
     const key = normDedupeKey(s.url);
     if (seenKeys.has(key)) continue; // 同键（www/m/mobile 归一）只留首个原始 URL
     seenKeys.add(key);
@@ -677,6 +680,8 @@ function parseUpdatedFromHtml(html) {
 /** 单 URL 抓取（含缓存两分与四层回退；每次网络尝试都过预算 gate）。成功返回：
  *  { content, tier, truncated, fetchedAt(ISO，缓存命中=真实原抓时间), updatedAt(可取得时), cache } */
 async function fetchTiered(ctx, url, title, state, budget, intent) {
+  // #72：黑名单站点直接不抓（缓存也不读）；不算失败，不写 note——这是用户主动配置的过滤
+  if (isDomainBlocked(url)) return null;
   const now = Date.now();
   const cached = getFresh(url, DOC_CACHE_MAX_AGE_MS);
   if (cached && (intent.freshness === "none" || canUseCache(cached.fetched_at, intent.freshness, now)[0])) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-free-search",
-  "version": "0.8.6",
-  "description": "Free web search for DeepSeek Harness: 24 engines (Bing/DuckDuckGo/AnySearch/SearXNG/Exa/Tavily/Keenable/Firecrawl/Parallel keyless; Zhihu global/site via MCP and Perplexity/SerpBase/DeepSeek/You.com/Baidu/Kimi/Aliyun/Doubao with key; OpenAI/Gemini/Claude model built-in search, explicit-only) + auto smart routing + global engine enable/disable & fallback priority + editable zh/en language pools + multi mode (parallel full language-pool merge) + multi_search cross-source tool + failure-aware fallback (quota/auth cooldown, transient retry, fallbackOn) + time filtering + platform search + web_fetch, with web settings UI.",
+  "version": "0.8.7",
+  "description": "Free web search for DeepSeek Harness: 24 engines (Bing/DuckDuckGo/AnySearch/SearXNG/Exa/Tavily/Keenable/Firecrawl/Parallel keyless; Zhihu global/site via MCP and Perplexity/SerpBase/DeepSeek/You.com/Baidu/Kimi/Aliyun/Doubao with key; OpenAI/Gemini/Claude model built-in search, explicit-only) + auto smart routing + global engine enable/disable & fallback priority + editable zh/en language pools + multi mode (parallel full language-pool merge) + multi_search cross-source tool + failure-aware fallback (quota/auth cooldown, transient retry, fallbackOn) + time filtering + platform search + domain blocklist (blockedDomains) + web_fetch, with web settings UI.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -20,6 +20,7 @@
     "lib/fetch_provider.js",
     "lib/fetch_upstream.js",
     "lib/weather.js",
+    "lib/domain_filter.js",
     "cordis.patch.yml"
   ],
   "keywords": [