@streamapp/stream 0.0.1

package/resources/packages/alist/manifests.yaml

@@ -0,0 +1,76 @@
+# AList 的 source 声明。三条，分两类：
+#
+# **可订阅的 feed（discoverable:true）**——用户能在「添加来源」里挑到、加进一条订阅：
+#   - alist-audio  把某个网盘目录下的音频文件当成节目采进来。
+#
+# **内部能力（discoverable:false）**——它们不是 feed，只是被别的机制按 id 直接调用；
+# 露在浏览目录里只会让人挑到一个加进订阅也不会产出条目的东西：
+#   - alist-list  供绑定向导选目录、增量同步 diff 网盘目录；
+#   - alist-resolve 声明 provides:[netdisk-file]，作为 Provider 成员候选被选为播放兜底源
+#     （把网盘文件路径解析成临时直链；播放优先走网盘直链，官方源兜底）。
+#
+# 认证走 config alist_token / ALIST_TOKEN（adapter 内解析并注入 AlistClient），
+# 故 manifest 的 auth 为 none——没有 per-request 的用户登录流。
+- id: alist-list
+  adapter: alist
+  title: AList 目录浏览
+  description: 列出用户 AList 实例某路径下的文件；枚举网盘目录，供绑定向导选目录与增量同步 diff 新文件。
+  topics: [alist, 网盘, 目录, 文件, 枚举, netdisk, 夸克网盘, 阿里云盘, 百度网盘]
+  categories: [resource]
+  capabilities: [search]
+  auth: { type: none }
+  discoverable: false
+  cadence_hint_seconds: 3600
+  params_schema:
+    path:
+      type: string
+      required: false
+      description: AList 绝对路径，如 /夸克网盘/我的转存/某剧。默认根目录 /。
+  fixed_params: { mode: list }
+- id: alist-resolve
+  adapter: alist
+  title: AList 直链解析
+  description: 把 AList 里的一个文件路径解析成可直连播放的临时直链（raw_url）；作为播放兜底 Provider 成员，命中网盘映射时优先直链。
+  topics: [alist, 网盘, 直链, 播放, 解析, raw_url, netdisk, 后备, 兜底]
+  categories: [resource]
+  capabilities: [anchor]
+  auth: { type: none }
+  discoverable: false
+  cadence_hint_seconds: 3600
+  # provides 令本源出现在 netdisk-file 目标类型的 Provider 成员候选里（对齐 pansou 的
+  # provides:[search-download]）；key_param=path 表明解析键就是网盘文件路径。
+  provides: [netdisk-file]
+  key_param: path
+  params_schema:
+    path:
+      type: string
+      required: true
+      description: AList 绝对文件路径，如 /夸克网盘/我的转存/某剧/01.mp4。
+  fixed_params: { mode: resolve }
+- id: alist-audio
+  adapter: alist
+  # 这一条是**用户挑得到的入口**（唯一的 discoverable:true），文案照着「浏览目录里的一张卡」
+  # 写：说清它产出什么、什么时候该用它，不写实现口径。
+  # 不变量（不属于展示文案，所以留在注释里）：与网盘**绑定**正交，不做去重——同一个文件既被
+  # 这条源采成条目、又被绑定配到某一集上时不会互相察觉；不重复靠用户在网盘侧只放该来源独有
+  # 的文件保证。
+  title: 网盘目录（音频）
+  description: 把网盘某个目录下的音频文件直接当成节目采进来——源站没有的那些（已下架、独家、自己转存的）走它。填一个目录路径即可，此后目录里新增的文件会在下次采集时进来。
+  topics: [alist, 网盘, 音频, 播客, 歌单, 目录, 下架, netdisk, 夸克网盘, 阿里云盘, 百度网盘]
+  categories: [resource]
+  capabilities: [search]
+  auth: { type: none }
+  discoverable: true
+  normalizer: alist
+  cadence_hint_seconds: 86400
+  params_schema:
+    path:
+      type: string
+      required: true
+      # widget 是**通用机制**：声明「这个字符串参数用哪种控件填」，前端 SourceParamField
+      # 照登记表挑控件（见那里的 PARAM_WIDGETS）。哪个网盘、哪条路径是站点知识，留在这里；
+      # 「可以用目录选择器填」是机制，留在前端。没有它这个参数就退成纯文本框，用户得手敲
+      # `/quark/来自：分享/播客付费节目合集/春典 JARGON` 这种路径。
+      widget: netdisk-dir
+      description: AList 绝对目录路径，如 /夸克网盘/怡乐下架。目录下的音频文件会被采成条目。
+  fixed_params: { mode: audio }

package/resources/packages/alist/mounts.ts

@@ -0,0 +1,120 @@
+import type { AlistStorage } from '../../src/netdisk/alist-client.ts'
+import type { CookieCloudCookie } from '../../src/types.ts'
+import { findPreset } from './presets.ts'
+
+/**
+ * 挂载 reconciler —— 期望态在 Stream 侧（settings 持久化的 mounts 配置），
+ * AList 只是执行器。启动时/挂载后对比 storage/list：
+ *   缺 → create；被标 disabled（cookie 失效）→ 拉新 cookie update + enable；
+ *   不认识的 storage（用户手动在别处建的）一概不动。
+ * 幂等：连跑两遍第二遍零变更。
+ */
+
+/** 期望态条目（settings.alist.mounts 持久化形态）。 */
+export interface MountEntry {
+  presetId: string
+  /** 缺省用 preset.mountPath。 */
+  mountPath?: string
+}
+
+/** reconciler 只依赖 client 的 4 个 admin 方法——便于单测注入 mock。 */
+export interface StorageAdmin {
+  listStorages(): Promise<AlistStorage[]>
+  createStorage(s: { mount_path: string; driver: string; addition: string }): Promise<void>
+  updateStorage(s: AlistStorage): Promise<void>
+  enableStorage(id: number): Promise<void>
+}
+
+/** cookie 来源（生产 = CookieCloudClient.fetch，单测注入固定表）。 */
+export type CookieSource = () => Promise<Record<string, CookieCloudCookie[]>>
+
+export interface ReconcileResult {
+  created: string[]
+  healed: string[]
+  /** 该域在 CookieCloud 里没 cookie —— UI 引导「用浏览器登录 xx」。 */
+  missingCookie: string[]
+  /** 已就绪无需动作。 */
+  ok: string[]
+}
+
+/** 单个 preset 的实时健康态（GET /api/netdisk/mounts 下发，UI 据此渲染）。 */
+export type MountStatus = 'mounted' | 'error' | 'cookieReady' | 'noCookie'
+
+/**
+ * 由 AList storage 现状 + cookie 可得性推 preset 健康：
+ *   有 storage 且未禁用/状态正常 → mounted；
+ *   有 storage 但被禁用或状态异常（cookie 多半失效）→ error；
+ *   无 storage 但有 cookie → cookieReady（可自动挂载）；
+ *   无 storage 且无 cookie → noCookie（待用扩展同步）。
+ */
+export function mountStatusOf(storage: AlistStorage | undefined, hasCookie: boolean): MountStatus {
+  if (storage) return !storage.disabled && (!storage.status || storage.status === 'work') ? 'mounted' : 'error'
+  return hasCookie ? 'cookieReady' : 'noCookie'
+}
+
+/**
+ * CookieCloud 域匹配：精确域、点前缀/子域变体，以及父域（`.quark.cn` 的 cookie
+ * 对 `pan.quark.cn` 生效 —— CookieCloud 常按裸父域存键）。
+ */
+export function cookiesForDomain(
+  all: Record<string, CookieCloudCookie[]>,
+  domain: string,
+): CookieCloudCookie[] | undefined {
+  const direct = all[domain]
+  if (direct?.length) return direct
+  for (const [k, v] of Object.entries(all)) {
+    if (!v.length) continue
+    const nk = k.replace(/^\./, '')
+    // 子域/点变体（www.115.com ← 115.com），或父域覆盖（quark.cn → pan.quark.cn）
+    if (nk === domain || nk.endsWith(`.${domain}`) || domain.endsWith(`.${nk}`)) return v
+  }
+  return undefined
+}
+
+function serializeCookies(cookies: CookieCloudCookie[]): string {
+  return cookies.map((c) => `${c.name}=${c.value}`).join('; ')
+}
+
+export async function reconcileMounts(
+  desired: MountEntry[],
+  admin: StorageAdmin,
+  fetchCookies: CookieSource,
+): Promise<ReconcileResult> {
+  const result: ReconcileResult = { created: [], healed: [], missingCookie: [], ok: [] }
+  if (desired.length === 0) return result // 无期望态就不拉 CookieCloud，省一次网络往返
+
+  const storages = await admin.listStorages()
+  const byPath = new Map(storages.map((s) => [s.mount_path, s]))
+  let cookieData: Record<string, CookieCloudCookie[]> | undefined // 惰性拉取，且只拉一次
+
+  for (const entry of desired) {
+    const preset = findPreset(entry.presetId)
+    if (!preset) continue // 未知 preset：配置陈旧，跳过不抛——不阻塞其余挂载
+    const mountPath = entry.mountPath ?? preset.mountPath
+    const existing = byPath.get(mountPath)
+
+    if (existing && !existing.disabled) {
+      result.ok.push(mountPath) // 已就绪：幂等第二遍全部走这条路径
+      continue
+    }
+
+    cookieData ??= await fetchCookies()
+    const cookies = cookiesForDomain(cookieData, preset.cookieDomain)
+    if (!cookies) {
+      result.missingCookie.push(mountPath)
+      continue
+    }
+    const addition = JSON.stringify({ ...preset.additionDefaults, cookie: serializeCookies(cookies) })
+
+    if (!existing) {
+      await admin.createStorage({ mount_path: mountPath, driver: preset.driver, addition })
+      result.created.push(mountPath)
+    } else {
+      // disabled = cookie 失效自愈路径：换 addition 后 enable
+      await admin.updateStorage({ ...existing, addition })
+      await admin.enableStorage(existing.id)
+      result.healed.push(mountPath)
+    }
+  }
+  return result
+}

package/resources/packages/alist/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@streamapp/alist",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "stream": {
+    "id": "alist",
+    "name": "AList",
+    "tagline": "网盘聚合，转存内容直链播放",
+    "description": "内置 AList 实例（支持夸克、阿里云盘、百度网盘等 40+ 存储）， 把转存的播单内容变成可直链播放的后备源。播放优先走网盘直链，官方源兜底。 全默认配置：bootstrap 自动接管 admin 凭证，挂载网盘只需浏览器登录过（CookieCloud 同步）。 ALIST_URL / ALIST_TOKEN env 仅作指向外部实例的调试逃生门，不出现在 UI。",
+    "repository": "https://github.com/AlistGo/alist",
+    "backend": {
+      "image": "xhofe/alist:latest",
+      "service": "alist",
+      "port": 5244,
+      "health": "/ping",
+      "volumes": ["alist-data:/opt/alist/data"],
+      "standby": {
+        "idleMinutes": 240
+      }
+    },
+    "code": { "entry": "./activate.ts", "adapters": ["alist"], "normalizers": ["alist"] }
+  }
+}

package/resources/packages/alist/presets.ts

@@ -0,0 +1,53 @@
+/**
+ * 挂载网盘 preset 表（v1 只列 cookie 登录型驱动）。
+ *
+ * 每个条目对应「挂载网盘」列表里的一个网盘：driver 对应 AList 驱动名，
+ * cookieDomain 是 CookieCloud 里的 cookie 域（用户在浏览器登录过即有），
+ * mountPath 是默认挂载点。addition 的字段 schema 不硬编码——UI 运行时从
+ * `GET /api/admin/driver/info?driver=xx` 拉取，这里只放 cookie 之外的必填默认值。
+ */
+export interface MountPreset {
+  /** preset 稳定 id（持久化到 mounts 配置里，不随 label 变）。 */
+  id: string
+  /** UI 展示名。 */
+  label: string
+  /** AList 驱动名（storage/create 的 driver 字段，原样传）。 */
+  driver: string
+  /** CookieCloud cookie_data 的键（域名，无协议前缀）。 */
+  cookieDomain: string
+  /** 默认挂载点。 */
+  mountPath: string
+  /** cookie 之外的 addition 默认值（JSON 序列化前的对象形态）。 */
+  additionDefaults: Record<string, unknown>
+}
+
+export const MOUNT_PRESETS: readonly MountPreset[] = [
+  {
+    id: '115',
+    label: '115 网盘',
+    driver: '115 Cloud',
+    cookieDomain: '115.com',
+    mountPath: '/115',
+    additionDefaults: { root_folder_id: '0' },
+  },
+  {
+    id: 'quark',
+    label: '夸克网盘',
+    driver: 'Quark',
+    cookieDomain: 'pan.quark.cn',
+    mountPath: '/quark',
+    additionDefaults: { root_folder_id: '0' },
+  },
+  {
+    id: 'uc',
+    label: 'UC 网盘',
+    driver: 'UC',
+    cookieDomain: 'drive.uc.cn',
+    mountPath: '/uc',
+    additionDefaults: { root_folder_id: '0' },
+  },
+] as const
+
+export function findPreset(id: string): MountPreset | undefined {
+  return MOUNT_PRESETS.find((p) => p.id === id)
+}

package/resources/packages/alist/provision.ts

@@ -0,0 +1,84 @@
+import { randomBytes } from 'node:crypto'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execFileP = promisify(execFile)
+
+/**
+ * Bootstrap 接管序列（决策 2026-07-08：内置托管是唯一形态）。
+ *
+ * AList 是实现细节：admin 密码由 Stream 生成并接管，用户永远不接触 AList UI/凭证。
+ * 序列（幂等）：
+ *   1. 已有存储密码 → 直接 login 换新 48h JWT（跑两遍不重设密码）；
+ *   2. login 失败（volume 重建导致密码漂移）→ 容器内 `alist admin set` 重设 → 再 login；
+ *   3. 无存储密码 → 生成随机密码 → admin set → login；
+ *   4. 密码 + token 持久化（settings.json alist 节点，与既有 token 同一安全域）。
+ *
+ * 调用方（bootstrap）负责就绪门控（health /ping 通过后才调用），本模块不做等待。
+ */
+
+export interface AlistCredentials {
+  password: string
+  token: string
+}
+
+export interface ProvisionDeps {
+  /** AList base url（内网地址，如插件网关或 http://alist:5244） */
+  baseUrl: string
+  /** 已存凭证（settings.json alist 节点） */
+  getStored: () => Partial<AlistCredentials>
+  /** 持久化凭证 */
+  save: (creds: AlistCredentials) => void
+  /** 容器内重设 admin 密码（默认 docker exec，测试注入 mock） */
+  execAdminSet: (password: string) => Promise<void>
+  fetchFn?: typeof fetch
+  genPassword?: () => string
+}
+
+/** POST /api/auth/login → 48h JWT。AList 统一 {code,data:{token}} 信封。 */
+export async function alistLogin(
+  baseUrl: string,
+  password: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<string> {
+  const r = await fetchFn(`${baseUrl.replace(/\/$/, '')}/api/auth/login`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ username: 'admin', password }),
+  })
+  const j = (await r.json()) as { code: number; message?: string; data?: { token?: string } }
+  if (!r.ok || j.code !== 200 || !j.data?.token)
+    throw new Error(`[alist] login 失败: ${j.code} ${j.message ?? ''}`)
+  return j.data.token
+}
+
+/** 宿主侧 docker exec 重设 admin 密码（xhofe/alist 镜像 workdir /opt/alist，二进制 ./alist）。 */
+export function dockerAdminSet(service = 'alist'): (password: string) => Promise<void> {
+  return async (password) => {
+    await execFileP('docker', ['exec', service, './alist', 'admin', 'set', password])
+  }
+}
+
+/** 接管序列入口。返回可用 token；所有失败路径 throw（调用方决定降级策略）。 */
+export async function provisionAlist(deps: ProvisionDeps): Promise<string> {
+  const fetchFn = deps.fetchFn ?? fetch
+  const gen = deps.genPassword ?? (() => randomBytes(18).toString('base64url'))
+  const stored = deps.getStored()
+
+  // 快路径：密码在手 → 只换 token，不动容器。
+  if (stored.password) {
+    try {
+      const token = await alistLogin(deps.baseUrl, stored.password, fetchFn)
+      deps.save({ password: stored.password, token })
+      return token
+    } catch {
+      // 密码漂移（volume 重建/手动改过）→ 落到重设路径，用存储密码保持稳定。
+    }
+  }
+
+  const password = stored.password ?? gen()
+  await deps.execAdminSet(password)
+  const token = await alistLogin(deps.baseUrl, password, fetchFn)
+  deps.save({ password, token })
+  return token
+}

package/resources/packages/baidu/baidu-share.recipe.json

@@ -0,0 +1,93 @@
+{
+  "version": 1,
+  "kind": "http",
+  "sourceId": "baidu-share",
+  "acceptNonOk": true,
+  "jar": true,
+  "output": "object",
+  "request": {
+    "url": "https://pan.baidu.com/share/list?uk={uk}&shareid={shareid}&order=other&desc=1&showempty=0&web=1&page=1&num=100&root=1&clienttype=0",
+    "method": "GET",
+    "headers": {
+      "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+      "referer": "https://pan.baidu.com/s/{pwd_id}"
+    },
+    "redirect": "manual"
+  },
+  "compute": {
+    "capabilities": [],
+    "params": "(() => { const id = String(input.params.pwd_id || ''); return { surl: id.charAt(0) === '1' ? id.slice(1) : id, t: String(input.now * 1000) } })()",
+    "prefetch": [
+      {
+        "as": "first",
+        "request": {
+          "url": "https://pan.baidu.com/api/shorturlinfo?shorturl={pwd_id}&root=1&web=1&clienttype=0",
+          "method": "GET",
+          "headers": {
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            "referer": "https://pan.baidu.com/s/{pwd_id}"
+          },
+          "redirect": "manual"
+        }
+      },
+      {
+        "as": "landing",
+        "parse": "none",
+        "request": {
+          "url": "https://pan.baidu.com/s/{pwd_id}",
+          "method": "GET",
+          "headers": {
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            "referer": "https://pan.baidu.com/s/{pwd_id}"
+          },
+          "redirect": "manual"
+        }
+      },
+      {
+        "as": "verify",
+        "request": {
+          "url": "https://pan.baidu.com/share/verify?surl={surl}&t={t}&channel=chunlei&web=1&app_id=250528&clienttype=0",
+          "method": "POST",
+          "headers": {
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            "referer": "https://pan.baidu.com/s/{pwd_id}",
+            "content-type": "application/x-www-form-urlencoded"
+          },
+          "body": "pwd={passcode}&vcode=&vcode_str=",
+          "redirect": "manual"
+        }
+      },
+      {
+        "as": "info",
+        "request": {
+          "url": "https://pan.baidu.com/api/shorturlinfo?shorturl={pwd_id}&root=1&web=1&clienttype=0",
+          "method": "GET",
+          "headers": {
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+            "referer": "https://pan.baidu.com/s/{pwd_id}"
+          },
+          "redirect": "manual"
+        }
+      }
+    ],
+    "sign": "(() => { const ok = (o) => o && o.errno === 0 ? o : null; const src = ok(input.pre.info) || ok(input.pre.first) || {}; return { url: 'https://pan.baidu.com/share/list?uk=' + encodeURIComponent(String(src.uk || '')) + '&shareid=' + encodeURIComponent(String(src.shareid || '')) + '&order=other&desc=1&showempty=0&web=1&page=1&num=100&root=1&clienttype=0' } })()",
+    "decode": "(() => { const first = input.pre.first; if (!first || typeof first.errno !== 'number') return { validity: 'unknown', files: [], reason: '百度没有返回 JSON（可能是风控页）' }; if (first.errno === 140) return { validity: 'not-usable', files: [], reason: String(first.show_msg || '链接不存在') }; if (first.errno !== 0 && first.errno !== -9) return { validity: 'unknown', files: [], reason: 'shorturlinfo errno ' + first.errno }; const pwd = String(input.params.passcode || ''); if (first.errno === -9 && !pwd) return { validity: 'unknown', files: [], reason: '需要提取码，帖子里没给' }; if (pwd) { const v = input.pre.verify; if (!v || typeof v.errno !== 'number') return { validity: 'unknown', files: [], reason: '提取码校验没有返回 JSON' }; if (v.errno !== 0) return { validity: 'unknown', files: [], reason: v.errno === -9 ? '提取码不对' : '提取码校验 errno ' + v.errno }; const info = input.pre.info; if (!info || info.errno !== 0) return { validity: 'unknown', files: [], reason: '解锁后 shorturlinfo errno ' + (info && info.errno) } } const body = input.body; if (!body || typeof body.errno !== 'number') return { validity: 'unknown', files: [], reason: 'share/list 没有返回 JSON' }; if (body.errno !== 0) return { validity: 'unknown', files: [], reason: 'share/list errno ' + body.errno }; const files = (body.list || []).map((f) => ({ name: String(f.server_filename || ''), is_dir: f.isdir === 1 || f.isdir === '1', size: Number(f.size || 0) })); return files.length ? { validity: 'alive', files: files } : { validity: 'not-usable', files: [], reason: '分享里没有文件' } })()"
+  },
+  "assert": [{ "path": "validity", "desc": "baidu 探针判决必须带 validity" }],
+  "meta": {
+    "description": "一条百度网盘分享 → 是否存活 + 文件列表（带提取码匿名解锁；netdisk-verify-baidu Provider 行的成员）。百度几乎每条分享都锁着提取码，没有它只能判「链接是否存在」——看不进去 → unknown，绝不判死。",
+    "topics": ["baidu", "百度网盘", "网盘", "验活", "分享", "netdisk"],
+    "categories": ["resource"],
+    "capabilities": ["anchor"],
+    "facility": { "key": "baidu", "label": "百度网盘" },
+    "discoverable": false,
+    "_why_pick_in": "只在 Provider 成员面挑得到，不在频道订阅面——netdisk-verify-baidu 行的成员",
+    "pick_in": ["provider"],
+    "cadence_hint_seconds": 3600,
+    "key_param": "pwd_id",
+    "params_schema": {
+      "pwd_id": { "type": "string", "required": true, "description": "百度分享 id（pan.baidu.com/s/<pwd_id>）" },
+      "passcode": { "type": "string", "required": false, "default": "", "description": "提取码；没有则只能判断链接是否存在（看不进去 → unknown，绝不判死）" }
+    }
+  }
+}

package/resources/packages/baidu/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@streamapp/baidu",
+  "version": "1.0.0",
+  "author": "stream",
+  "keywords": [
+    "stream-recipe"
+  ],
+  "stream": {
+    "type": "recipe",
+    "_why_name": "叫「百度网盘」不叫「百度」：搜索那一份是隔壁的 packages/baidu-search（两件事只是域名同姓，见那份的 _why_own_package_not_packages_baidu）。面板上两条都摆着，名字不点明就只能靠 id 区分。",
+    "name": "百度网盘",
+    "tagline": "验分享链是否存活 + 列文件",
+    "facility": "baidu",
+    "schemaVersion": 1
+  }
+}

package/resources/packages/baidu-search/baidu-search.recipe.json

@@ -0,0 +1,129 @@
+{
+  "version": 1,
+  "kind": "browser",
+  "sourceId": "baidu-search",
+  "_why_allow_empty": "**「百度明确说未找到」是一个成功的 0 条，不是失败。** 这条腿的 0 条有两种来源，处置完全相反：百度换上那张 `.content_none`「抱歉，未找到相关结果。」的页 → 成功空（allowEmpty 收下，梯子据此告诉模型「确实没搜到」）；条目选择器漂了 / 撞上安全验证 → 抛错（等待步自己判，见它的头注）。allowEmpty 在这里**不会**把「静默 0 条」放回来，因为漂移那条路根本走不到这里。",
+  "allowEmpty": true,
+  "_why_cookie_domain": "百度搜索不需要登录，这一格只是「这个包能走到哪些域」的申报（装载器拿它卡 goto 的落点，见 `src/replay/recipe-import.ts`）。填 baidu.com 以覆盖 www 子域。",
+  "cookieDomain": "baidu.com",
+  "_why_browser": "和 google / brave 那两条腿同一个理由：值钱的是**用户自己那个 Chrome**。百度在这条链路上补的不是冗余而是**中文长尾覆盖**——实测「怡楽播客 小宇宙」这类查询它回 10 条真结果（xiaoyuzhoufm 官方页、B 站、荔枝、蜻蜓、Apple 播客），而 Google/Brave 对这类中文小站覆盖差。它**不是 Google 的备胎**（那是 Brave），所以判据按语言分流，不按失败分流：查询里有 CJK 就和 Google 并行跑（`src/search/web-search-ladder.ts` 的 `pickBrowserLegs`）。",
+  "_why_entry_is_homepage": "entryUrl 是**首页**、搜索 URL 在 step#0 的 goto 上，这不是绕路：expect 的判据必须有区分力——动作前为假、动作后为真（browser-harvest/references/authoring.md §3.5）。实测首页 `#content_left` 与 `.content_none` 双双命中 0，任何一张结果页上至少命中 1，于是这个 expect 是真监督。直接把搜索 URL 当 entryUrl 的话，唯一能写的 expect 在动作之前就已经成立，引擎当场判它恒真（StepExpectVacuousError）。",
+  "entryUrl": "https://www.baidu.com/",
+  "entryWait": "load",
+  "_why_login_check": "这个源不需要登录，两个信号因此各自换了个更有用的意思：loggedIn 用搜索框 `input#kw`（实测首页和结果页都恰好 1 个，命中 = 我们拿到的是百度真页面）。**别照抄 google 那份的 `textarea[name=q]`**：百度的框是 `input#kw`。wall 是一组**没有实测到的**候选——这台机器上一次都没撞见百度的安全验证（`wappass.baidu.com` 那张「百度安全验证」页），所以只能按已知形状先摆着。**它没命中不会造成静默错**：真撞上时页面里既没有 `#content_left` 也没有 `.content_none`，等待步会当成「页面没到位」抛错（响，且会被检疫），只是错误信息说得没那么准。真撞见一次就回来把选择器改准。",
+  "loginCheck": {
+    "loggedIn": "input#kw",
+    "wall": ".passMod_dialog-container, #wrapper .vcode-body, form[action*=\"wappass\"]"
+  },
+  "_why_one_shot": "session.lifecycle = one-shot：查完就关。这条腿是对话里临时补一发搜索，不是持续采集——没有账本要留、没有 feed 要骑，留一个常驻标签只会白占用户浏览器里的一格。",
+  "_why_own_facility": "facility 是 `baidu-search` 而不是 `baidu`：`packages/baidu/` 那个包已经占着 `baidu`，它是**百度网盘**（`baidu-share`，打 pan.baidu.com 验分享链）。facility 是 lane / tab / 限速桶的归属键，两件事共用一个键就会互相牵连——理由写在 `package.json` 的 `_why_own_package_not_packages_baidu` 里。",
+  "session": {
+    "facility": "baidu-search",
+    "lifecycle": "one-shot",
+    "visibility": "unattended"
+  },
+  "steps": [
+    {
+      "_why": "{query} 由调用方按 URL 组件编码好再传进来（substitute 是纯文本替换，不编码）——查询词里一个 `#` 就会把 querystring 截断，而截断之后百度照样回一页结果，于是「搜错了」长得和「搜到了」一模一样。不加任何条数参数：实测一页 8–10 条自然结果，够 targetCount 取 10。",
+      "kind": "goto",
+      "url": "https://www.baidu.com/s?wd={query}",
+      "_why_expect_is_the_page_not_the_results": "这道闸门只判「我们拿到了一张真的百度结果页」，**不判它有没有结果**——两件事必须分开，否则「百度确实没有」和「选择器漂了」会合并成同一个失败，而那正是这条链路上最贵的一种混淆。实测三态（2026-08-13 活体量的）：首页 `#content_left`=0 且 `.content_none`=0（所以这个 expect 非恒真）；有结果页 `#content_left`=1；**未找到的页 `#content_left` 整个不存在，换成 `.content_none > .nors`「抱歉，未找到相关结果。」**。所以 union 命中 = 页面到了，两种 SERP 都算。**百度是第三种形状，别照抄另外两家**：Google 没结果时 `#rso` 消失、Brave 是容器还在换一张 `.fallback-snippet` 卡，百度是容器消失且另有一个具名的空态块。timeout 8s：实测渲染 2 秒出头。",
+      "expect": {
+        "selector": "#content_left, .content_none",
+        "timeout": 8000
+      }
+    },
+    {
+      "_why": "**这一步只做一件事：等结果列表不再长了。** 结果是渐进出现的，observer 早读一步就少读几条，而少读不会报错。所以在读之前先在页面里数着自然结果，连着 3 次 200ms 读数不变才算画完，封顶 3s。它不产 item（items 恒空），产出全在下面那个 dom observer 里。",
+      "_why_not_scroll_or_settle": "**这个等待刻意不用 settle，也不用 scroll。** settle 要「逼出一帧」（逐帧截图比字节），落到 `Page.captureScreenshot`，而对着后台标签这条 relay 命令在这台机器上稳定挂到 30s 超时（详见 browser-harvest/references/failure-atlas.md 4.3.6）。scroll 则是另一个理由：driver 今天一帧都不逼、滚动本身不贵了，但本步只是「等结果区 DOM 稳定」，滚动对它没有意义，白等一个 dwell。换成纯 `Runtime.evaluate` 的等待是几十毫秒。**判据：需要真帧的东西才配付这个价**，而「等 DOM 稳定」根本不需要帧——它是 Tier A。",
+      "_why_it_also_judges": "**这一步负责把「百度确实没有」和「我们读不到了」分开，而且必须分成「成功空」和「抛错」两种收场**——因为失败在这条链路上不只是一句话，**它带着检疫**：`RepairLedger` 见到一个源反复失败就把它隔离，之后 `ReplayAdapter.fetch` 直接 `return DECLINED`（`src/adapters/replay/adapter.ts`），**连浏览器都不开、也不报错**，表现就是这条腿静默死掉（2026-08-12 google 那条腿真撞过）。判据是对活体量出来的，分三档：(1) `.content_none` 在 = 百度明确说未找到 → **正常返回空**（成功的 0 条）；(2) `#content_left` 也不在 = 页面根本没到位 / 撞上安全验证 → **抛错**；(3) `#content_left` 在却一条自然结果都读不到 → **抛错**（漂了，或整页只剩广告）。**注意百度极不愿意回 0 条**：实测随机串 `qzxjvwrtplmnbgh8827364` 它回 10 条模糊结果，加引号的精确匹配也被丢掉运算符照回结果——真正走到 `.content_none` 的是 `site:<不存在的域>`。所以第 (3) 档在实践中几乎只可能是漂移，判成抛错是对的。**字段也要在这里验一次**（第一张卡必须取得出 `mu` 属性和 h3）：开了 `allowEmpty` 之后，observer 的**字段**选择器漂了会表现成「条目在、link 取不到 → 被 dedupe 丢光 → 0 条」，而 0 条现在是合法的成功——不在这一步拦住，它就变成一个安静的空答案。这一步和 observer 用同一批选择器不是重复：这里是**判据**（漂了就响），那里是**取数**。",
+      "kind": "evaluate",
+      "call": "async () => { const sel = \"#content_left > div[mu^='http']:not([mu*='nourl.ubs.baidu.com']):not([mu*='.recommend_list.baidu.com']):has(h3 a[href])\"; let last = -1, stable = 0; for (let i = 0; i < 15 && stable < 3; i++) { const c = document.querySelectorAll(sel).length; stable = (c > 0 && c === last) ? stable + 1 : 0; last = c; await new Promise(r => setTimeout(r, 200)); } const cards = document.querySelectorAll(sel); if (cards.length === 0) { if (document.querySelector('.content_none')) return { items: [] }; if (!document.querySelector('#content_left')) throw new Error('[baidu] 既没有结果容器 #content_left、也没有「抱歉，未找到相关结果」那张 .content_none —— 页面没到位或撞上了安全验证'); throw new Error('[baidu] 结果容器在，但一条自然结果都没读到 —— 条目选择器漂了（或整页只剩广告）'); } const first = cards[0]; if (!first.getAttribute('mu') || !first.querySelector('h3')) { throw new Error('[baidu] 读到了条目，但取不出标题或真实链接 —— 字段选择器漂了'); } return { items: [] }; }",
+      "itemsAt": "items",
+      "maxPages": 1
+    }
+  ],
+  "observers": [
+    {
+      "_why_selectors": "2026-08-13 对活体重定过（三条查询：中文长尾「怡楽播客 小宇宙」、商业词「北京装修公司排名」、`site:<不存在的域>`）。条目单位是 `#content_left > div`，但**必须过滤**，因为百度的结果列里混着四类非自然结果：买词广告、相关搜索块、百度自己的问卷/AI 卡、以及 `recommend_list`。**过滤的支点是 `mu` 属性**——它是百度给每条自然结果标注的**真实目标 URL**，而**广告卡一律没有 `mu`**（实测商业词那页：4 张带「广告」角标的卡 + 3 个无 tpl 的推广块，`mu` 全为空；8 条自然结果 `mu` 全是真域名）。再排掉两个百度自留的假 URL 前缀：`nourl.ubs.baidu.com`（问卷卡 / AI 生成卡）和 `<数字>.recommend_list.baidu.com`（相关搜索）。最后 `:has(h3 a[href])` 排掉没有标题链接的块。**刻意不用 class**：`.result` / `.c-container` / `.new-pmd` 覆盖不准（`.result-op` 里既有百科这种真结果也有问卷卡），而卡片内部那些 `title-box_6uu5k` / `content-gap_3jlQr` 是编译期哈希、改一行样式就换一批。`mu` / `tpl` / `data-module` 是百度多年不动的语义属性。",
+      "_why_link_is_mu_not_the_redirect": "**link 直接读卡片自己的 `mu` 属性，不读 `h3 a` 的 href。** 那个 href 是 `http://www.baidu.com/link?url=…` 的中转链，要拿到真实 URL 得**多打一次请求**去跟重定向——而真实 URL 本来就明明白白写在同一张卡的 `mu` 上（实测逐条核对：`mu` 全是可直接打开的目标地址，如 `https://www.xiaoyuzhoufm.com/podcast/…`、`https://space.bilibili.com/…`）。**为什么不能把中转链直接甩给模型**：`web_search` 的下游是模型自己决定要不要 `read_url`，中转链会让每条结果多一跳、URL 里看不出是哪个站（模型据此判切题的能力当场作废），去重也会失效——实测同一条查询里两条**不同**结果的 `link?url=` 前缀完全一样，只有尾部不同，而 `mu` 一眼可分。**代价**：`mu` 是百度私有属性，它改名这条腿会 0 条——所以上面那个等待步显式验了第一张卡取不取得出 `mu`，漂了会抛错而不是安静地空。",
+      "_why_dom": "百度的结果是 SSR 进 HTML 的，页面不为它发 XHR——network observer 在这里没有东西可拦。",
+      "kind": "dom",
+      "itemSelector": "#content_left > div[mu^='http']:not([mu*='nourl.ubs.baidu.com']):not([mu*='.recommend_list.baidu.com']):has(h3 a[href])",
+      "fields": {
+        "title": {
+          "selector": "h3"
+        },
+        "link": {
+          "attr": "mu"
+        },
+        "snippet": {
+          "selector": "[data-module='abstract']"
+        }
+      },
+      "trigger": "final"
+    }
+  ],
+  "output": {
+    "itemsAt": "items",
+    "_why_dedupe_link": "dom observer 产出的「原始条目」就是上面那张扁平卡片，所以 dedupeBy 走 link（= `mu`，页内唯一、也是这条结果的身份；中转链反而**不唯一**，见上面那段）。**注意这条路自己不会喊**：选择器漂了 → link 取不到 → 每条都因缺身份被丢 → 0 条，而 `allowEmpty` 开着，0 条是合法的成功。所以「漂了要响」这件事**不由这里保证**，由上面那个等待步的判据保证（它验条目数、也验第一张卡取不取得出 `mu` 和 h3）。两处的分工写在那一步的 `_why_it_also_judges` 里——改任何一边之前先读它。",
+    "dedupeBy": "link",
+    "targetCount": 10,
+    "mapping": {
+      "title": "title",
+      "link": "link",
+      "snippet": "snippet",
+      "guid": "link"
+    },
+    "assert": [
+      {
+        "path": "items",
+        "desc": "baidu #content_left 里一条自然结果都没读到 —— 选择器漂移或撞上了安全验证页"
+      }
+    ]
+  },
+  "policy": {
+    "minActionIntervalMs": 500,
+    "maxTaskMs": 60000
+  },
+  "meta": {
+    "description": "百度网页搜索 — 在用户自己的 Chrome 里打开结果页，读 SSR 出来的自然结果（title/link/snippet），link 取卡片的 mu 属性即真实目标 URL。它补的是 web_search 的中文长尾覆盖",
+    "type": "post",
+    "title": "网页搜索",
+    "topics": [
+      "baidu",
+      "百度",
+      "搜索",
+      "search",
+      "web"
+    ],
+    "categories": [
+      "news"
+    ],
+    "facility": {
+      "key": "baidu-search",
+      "label": "百度搜索"
+    },
+    "capabilities": [
+      "search"
+    ],
+    "provides": [
+      "search-content"
+    ],
+    "key_param": "query",
+    "priority": 50,
+    "_why_not_discoverable": "不进发现列表：它不是一个「可订阅的信息源」（没人要一条定时跑的搜索），只是 web_search 借的一条腿。",
+    "discoverable": false,
+    "_why_pick_in": "只在 Provider 成员面挑得到，不在频道订阅面——web_search 第二档的一条腿",
+    "pick_in": ["provider"],
+    "cadence_hint_seconds": 300,
+    "homepage": "www.baidu.com",
+    "params_schema": {
+      "query": {
+        "type": "string",
+        "required": true,
+        "description": "搜索词，**已按 URL 组件编码**（调用方负责 encodeURIComponent）"
+      }
+    }
+  }
+}

package/resources/packages/baidu-search/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@streamapp/baidu-search",
+  "version": "1.0.0",
+  "author": "stream",
+  "keywords": [
+    "stream-recipe"
+  ],
+  "stream": {
+    "type": "recipe",
+    "_why_own_package_not_packages_baidu": "**百度网页搜索单独一个包、单独一个 facility，不并进 `packages/baidu/`**——那个包是**百度网盘**（`baidu-share`，facility 标签就叫「百度网盘」，kind:http 打 pan.baidu.com 验分享链）。两件事只是域名同姓：搜索不需要登录、网盘全靠登录态。合并的代价是实打实的：`stream.rateLimit` 是**按 facility 归并**的一个桶（`mergeRecipePackagesByFacility`），把「像人一样每分钟最多 10 次」压到 facility `baidu` 上，就等于顺手给网盘的批量验链装了个闸——那条路上没有人要这个闸，而且它坏起来是「批量验链忽然变慢」这种查不到源头的样子。",
+    "name": "百度",
+    "tagline": "网页搜索（中文长尾）",
+    "facility": "baidu-search",
+    "schemaVersion": 1,
+    "_why_cookieDomain": "百度搜索**不需要登录**，这一格填的不是「去哪儿取登录态」，而是「这个包能走到哪些域」——装载器拿它卡 goto 的落点（`src/replay/recipe-import.ts`：goto 的 host 必须落在 cookieDomain 之内，否则拒绝装载）。填 baidu.com 覆盖 www 子域。",
+    "cookieDomain": "baidu.com",
+    "_why_rateLimit": "和 google / brave 那两份同一个节奏、同一个理由：连着敲三次是正常的（burst 3），持续每分钟十次以上就不像人了（perMinute 10）。maxWaitMs 3000 是关键那条——这条腿长在对话热路径上（中文查询时和 Google **并行**跑），桶空了默认行为是「等」，等在对话里就是用户干瞪着 spinner；3 秒排不上就抛 RateLimitedError，梯子当场把这条腿当作不存在、Google 的结果照常给出去。",
+    "_why_no_perHour": "**故意不声明每小时累计预算**（google / brave 那两份有）。同一次实测里，Google 一小时约百发之后稳定被拦、同出口的 Brave 跟着弹人机验证，而**百度不受影响**——它没有表现出「按累计量拦人」这一维。往这里凭手感填一个数，等于用一个没有证据的闸门去卡一条正在正常工作的腿，而它坏起来的样子是「中文那条腿忽然常年缺席」，还不报错（梯子当它不存在）。哪天百度真撞出累计拦截，就在这里加 perHour 并把实测写进这段。",
+    "rateLimit": {
+      "burst": 3,
+      "perMinute": 10,
+      "maxWaitMs": 3000
+    }
+  }
+}