feat: add Youdao Notes shared note reader adapter (#1547)

* feat: add Youdao Notes shared note reader adapter

Add a new adapter for reading publicly shared Youdao Notes (有道云笔记).

- youdao note <url>: Fetches a public shared note by its share URL
  using browser-based DOM extraction. Extracts title, content, and
  keyword tags from the React-rendered page.
- Supports note.youdao.com and note.youdao.cn share URLs.
- Includes test coverage (3 tests) and documentation.

Closes #1418

* fix: extract full note content from React Redux store

Previously the adapter only extracted the AI summary section from the
DOM. Now it accesses the React fiber tree to read the full note content
from the Redux store (store.content.data.content), which contains the
complete note body in Youdao's structured format.

The extractor recursively walks Youdao's proprietary node format (key '8'
for text content) to reconstruct the full note as plain text.

* fix(youdao): harden shared note reader contract

---------

Co-authored-by: huzekang <huzekang@opencode.ai>
Co-authored-by: jackwener <jakevingoo@gmail.com>

Author: 3 people

README.md

@@ -277,6 +277,7 @@ To load the source Browser Bridge extension:
 | **wanfang** | `search` |
 | **hackernews** | `top` `new` `best` `ask` `show` `jobs` `search` `user` |
 | **xiaoyuzhou** | `auth*` `podcast*` `podcast-episodes*` `episode*` `download*` `transcript*` |
+| **youdao** | `note` |
 
 100+ site surfaces in total — **[→ see all supported sites & commands](./docs/adapters/index.md)**
 

README.zh-CN.md

@@ -263,6 +263,7 @@ npm link
 | **zhihu** | `hot` `search` `question` `download` `follow` `like` `favorite` `comment` `answer` | 浏览器 |
 | **weixin** | `download` | 浏览器 |
 | **youtube** | `search` `video` `transcript` `comments` `channel` `playlist` `feed` `history` `watch-later` `subscriptions` `like` `unlike` `subscribe` `unsubscribe` | 浏览器 |
+| **youdao** | `note` | 公开 |
 | **boss** | `search` `detail` `recommend` `joblist` `greet` `batchgreet` `send` `chatlist` `chatmsg` `invite` `mark` `exchange` `resume` `stats` | 浏览器 |
 | **coupang** | `search` `add-to-cart` | 浏览器 |
 | **bbc** | `news` | 公共 API |

cli-manifest.json

@@ -27604,6 +27604,36 @@
     "sourceFile": "yollomi/video.js",
     "navigateBefore": "https://yollomi.com"
   },
+  {
+    "site": "youdao",
+    "name": "note",
+    "description": "Read a public shared Youdao Note",
+    "access": "read",
+    "domain": "share.note.youdao.com",
+    "strategy": "public",
+    "browser": true,
+    "args": [
+      {
+        "name": "url",
+        "type": "str",
+        "required": true,
+        "positional": true,
+        "help": "Full share URL of the Youdao Note"
+      }
+    ],
+    "columns": [
+      "title",
+      "content",
+      "summary",
+      "keywords",
+      "created_at",
+      "file_size",
+      "url"
+    ],
+    "type": "js",
+    "modulePath": "youdao/note.js",
+    "sourceFile": "youdao/note.js"
+  },
   {
     "site": "youtube",
     "name": "channel",

clis/youdao/note.js

@@ -0,0 +1,258 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const ALLOWED_HOSTS = new Set([
+  'share.note.youdao.com',
+  'note.youdao.com',
+  'share.note.youdao.cn',
+  'note.youdao.cn',
+]);
+
+function unwrapEvaluateResult(payload) {
+  if (payload && !Array.isArray(payload) && typeof payload === 'object' && 'session' in payload && 'data' in payload) {
+    return payload.data;
+  }
+  return payload;
+}
+
+function normalizeShareUrl(raw) {
+  const value = String(raw ?? '').trim();
+  if (!value) {
+    throw new ArgumentError('youdao note url cannot be empty', 'Pass a full public share URL from Youdao Notes.');
+  }
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new ArgumentError('Invalid Youdao Note URL', 'Example: https://share.note.youdao.com/ynoteshare/index.html?id=...&type=note');
+  }
+  if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+    throw new ArgumentError('Youdao Note URL must use http or https');
+  }
+  if (!ALLOWED_HOSTS.has(parsed.hostname)) {
+    throw new ArgumentError('Youdao Note URL must be under note.youdao.com or note.youdao.cn');
+  }
+  if (!parsed.searchParams.get('id')) {
+    throw new ArgumentError('Youdao Note URL must include an id query parameter');
+  }
+  const type = parsed.searchParams.get('type');
+  if (type && type !== 'note') {
+    throw new ArgumentError('youdao note only accepts shared note URLs', 'Shared notebooks are not implemented yet.');
+  }
+  return parsed.toString();
+}
+
+function formatYoudaoTimestamp(value) {
+  if (value == null || value === '') return '';
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) return String(value);
+  const millis = numeric < 10_000_000_000 ? numeric * 1000 : numeric;
+  const date = new Date(millis);
+  if (Number.isNaN(date.getTime())) return String(value);
+  return date.toISOString();
+}
+
+function buildExtractorJs() {
+  const walkTextFn = `
+    function walkText(node, out) {
+      if (!node || typeof node !== 'object') return;
+      if (Array.isArray(node)) {
+        for (var i = 0; i < node.length; i += 1) walkText(node[i], out);
+        return;
+      }
+      if (typeof node[8] === 'string') {
+        var text = node[8].replace(/\\s+/g, ' ').trim();
+        if (text) out.push(text);
+      }
+      var keys = Object.keys(node);
+      for (var j = 0; j < keys.length; j += 1) {
+        var value = node[keys[j]];
+        if (value && typeof value === 'object') walkText(value, out);
+      }
+    }
+  `;
+  return `
+    (function() {
+      ${walkTextFn}
+      function cleanText(value) {
+        return String(value || '').replace(/\\u00a0/g, ' ').replace(/[ \\t]+\\n/g, '\\n').replace(/\\n{3,}/g, '\\n\\n').trim();
+      }
+      function pageText() {
+        return cleanText((document.body && (document.body.innerText || document.body.textContent)) || '').slice(0, 1000);
+      }
+      function classifyBodyText(text) {
+        if (/登录|登陆|请先登录|无权|权限|访问受限|验证码|安全验证|login|forbidden|permission/i.test(text)) return 'auth';
+        if (/分享已取消|分享不存在|文件不存在|笔记不存在|页面不存在|已过期|不存在|not found|404/i.test(text)) return 'not_found';
+        return '';
+      }
+      function findStoreState(value, depth, seen) {
+        if (!value || typeof value !== 'object' || depth > 10) return null;
+        if (seen.indexOf(value) !== -1) return null;
+        seen.push(value);
+        if (value.storeState && typeof value.storeState === 'object') return value.storeState;
+        if (value.content && value.content.data && typeof value.content.data === 'object') return value;
+        var keys = Object.keys(value);
+        for (var i = 0; i < keys.length; i += 1) {
+          var found = findStoreState(value[keys[i]], depth + 1, seen);
+          if (found) return found;
+        }
+        return null;
+      }
+      function findStoreFromFiber(fiber) {
+        var cursor = fiber;
+        var stack = [];
+        while (cursor || stack.length) {
+          if (!cursor) {
+            cursor = stack.pop();
+            continue;
+          }
+          var fromState = findStoreState(cursor.memoizedState, 0, []);
+          if (fromState) return fromState;
+          var fromProps = findStoreState(cursor.memoizedProps, 0, []);
+          if (fromProps) return fromProps;
+          if (cursor.sibling) stack.push(cursor.sibling);
+          cursor = cursor.child;
+        }
+        return null;
+      }
+      var root = document.querySelector('#root');
+      var body = pageText();
+      var bodyKind = classifyBodyText(body);
+      if (!root) {
+        return [false, bodyKind || 'root_missing', body];
+      }
+      var reactKey = Object.keys(root).find(function(key) { return key.indexOf('__reactContainer$') === 0; });
+      var fiber = (root._reactRootContainer && root._reactRootContainer._internalRoot && root._reactRootContainer._internalRoot.current)
+        || (reactKey ? root[reactKey] : null);
+      if (!fiber) {
+        return [false, bodyKind || 'react_root_missing', body];
+      }
+      var store = findStoreFromFiber(fiber);
+      if (!store) {
+        return [false, bodyKind || 'store_missing', body];
+      }
+      var contentData = store.content && store.content.data;
+      if (!contentData || typeof contentData !== 'object') {
+        return [false, bodyKind || 'content_data_missing', body];
+      }
+      var title = cleanText(contentData.tl || document.querySelector('.file-name')?.textContent || document.title || '');
+      var hasContentField = Object.prototype.hasOwnProperty.call(contentData, 'content');
+      var rawContent = hasContentField ? String(contentData.content || '') : '';
+      var content = '';
+      if (rawContent) {
+        try {
+          var parsed = JSON.parse(rawContent);
+          var parts = [];
+          walkText(parsed, parts);
+          content = cleanText(parts.join('\\n'));
+        } catch (error) {
+          content = cleanText(rawContent);
+        }
+      }
+      var summary = '';
+      var keywords = [];
+      var ai = store.aiSummary;
+      if (ai && ai.aiSummary) {
+        try {
+          var aiPayload = JSON.parse(ai.aiSummary);
+          summary = cleanText(aiPayload.description || '');
+          if (Array.isArray(aiPayload.keywords)) {
+            for (var i = 0; i < aiPayload.keywords.length; i += 1) {
+              var keyword = aiPayload.keywords[i];
+              if (keyword && keyword.title) keywords.push(cleanText(((keyword.emoji || '') + ' ' + keyword.title).trim()));
+            }
+          }
+        } catch {}
+      }
+      return [true, title, content, summary, keywords.join(' | '), contentData.ct || null, contentData.sz || null, hasContentField, rawContent.length, window.location.href];
+    })()
+  `;
+}
+
+function normalizeExtractionResult(payload, sourceUrl) {
+  const data = unwrapEvaluateResult(payload);
+  if (!Array.isArray(data)) {
+    throw new CommandExecutionError('Youdao note extractor returned a malformed payload');
+  }
+  const ok = data[0] === true;
+  if (!ok) {
+    const reason = typeof data[1] === 'string' && data[1].trim() ? data[1].trim() : 'unknown_parser_failure';
+    if (reason === 'auth') {
+      throw new AuthRequiredError('note.youdao.com', 'Youdao shared note requires login or additional permission');
+    }
+    if (reason === 'not_found') {
+      throw new EmptyResultError('youdao note', 'The shared note is missing, expired, cancelled, or inaccessible.');
+    }
+    throw new CommandExecutionError(`Youdao note parser failed: ${reason}`);
+  }
+  const title = String(data[1] ?? '');
+  const content = String(data[2] ?? '');
+  const summary = String(data[3] ?? '');
+  const keywords = String(data[4] ?? '');
+  const createTime = data[5];
+  const fileSize = data[6];
+  const hasContentField = data[7] === true;
+  const rawContentLength = Number(data[8] ?? 0);
+  const finalUrl = String(data[9] || sourceUrl);
+  if (!title) {
+    throw new CommandExecutionError('Youdao note parser did not extract a title');
+  }
+  if (!hasContentField) {
+    throw new CommandExecutionError('Youdao note parser did not find full note content in the page store');
+  }
+  if (rawContentLength > 0 && !content) {
+    throw new CommandExecutionError('Youdao note parser found note content but extracted no readable text');
+  }
+  const row = {};
+  row.title = title;
+  row.content = content;
+  row.summary = summary;
+  row.keywords = keywords;
+  row.created_at = formatYoudaoTimestamp(createTime);
+  row.file_size = fileSize == null ? '' : String(fileSize);
+  row.url = finalUrl;
+  return row;
+}
+
+var command = cli({
+  site: 'youdao',
+  name: 'note',
+  access: 'read',
+  description: 'Read a public shared Youdao Note',
+  domain: 'share.note.youdao.com',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: 'url', positional: true, required: true, help: 'Full share URL of the Youdao Note' },
+  ],
+  columns: ['title', 'content', 'summary', 'keywords', 'created_at', 'file_size', 'url'],
+  func: async function(page, kwargs) {
+    const url = normalizeShareUrl(kwargs.url);
+    try {
+      await page.goto(url);
+    } catch (error) {
+      throw new CommandExecutionError(`Failed to open Youdao Note URL: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+      await page.wait({ selector: '#root, .file-name, body', timeout: 10 });
+    } catch {
+      await page.wait(3).catch(function() {});
+    }
+    await page.wait(2).catch(function() {});
+    let payload;
+    try {
+      payload = await page.evaluate(buildExtractorJs());
+    } catch (error) {
+      throw new CommandExecutionError(`Youdao note extractor failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return [normalizeExtractionResult(payload, url)];
+  },
+});
+
+export var __test__ = {
+  buildExtractorJs: buildExtractorJs,
+  command: command,
+  formatYoudaoTimestamp: formatYoudaoTimestamp,
+  normalizeExtractionResult: normalizeExtractionResult,
+  normalizeShareUrl: normalizeShareUrl,
+};