@sovovs/bycli 2.1.36 → 2.1.38

package/clis/52pojie/search.js

@@ -0,0 +1,32 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireSearchQuery, runBrowserStep } from '../_shared/search-adapter.js';
+
+const SORTS = ['relevance', 'latest', 'replies', 'views'];
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, section, sort }) {
+  const url = new URL('https://www.52pojie.cn/search.php'); url.searchParams.set('srchtxt', keyword); url.searchParams.set('page', String(page)); url.searchParams.set('perpage', String(limit));
+  if (section) url.searchParams.set('section', section); if (sort) url.searchParams.set('sort', sort); return url.toString();
+}
+
+function extractItems() {
+  const body = document.body?.textContent || ''; const blocked = /验证码|访问频繁|captcha|access denied/i.test(body); const items = []; const seen = new Set(); const numberFrom = (card, selector) => { const value = (card.querySelector(selector)?.textContent || '').replace(/[^\d.]/g, ''); return value ? Number(value) : null; };
+  for (const card of document.querySelectorAll('.forum-item, .search-list li, .sltm')) {
+    const anchor = card.querySelector('.thread-title[href], h3 a[href], h2 a[href]'); if (!anchor || !/^https?:/i.test(anchor.href) || seen.has(anchor.href)) continue; seen.add(anchor.href); const time = card.querySelector('time');
+    items.push({ title: (anchor.textContent || '').trim(), url: anchor.href, snippet: (card.querySelector('.summary, .desc, p')?.textContent || '').trim(), displayUrl: new URL(anchor.href).hostname + new URL(anchor.href).pathname, source: '52pojie', resultType: 'thread', author: (card.querySelector('.author, .username')?.textContent || '').trim() || null, publishedAt: time?.getAttribute('datetime') || null, score: null, extra: { replies: numberFrom(card, '.replies, .reply'), views: numberFrom(card, '.views, .view'), section: (card.querySelector('.section, .forum')?.textContent || '').trim() || null } });
+  }
+  return { blocked, items };
+}
+
+export const command = cli({
+  site: '52pojie', name: 'search', access: 'read', description: 'Search 52pojie', domain: 'www.52pojie.cn', strategy: Strategy.PUBLIC, browser: true,
+  args: [{ name: 'keyword', positional: true, required: true, help: 'Search query' }, { name: 'limit', type: 'int', default: 10, help: 'Number of threads (1-50)' }, { name: 'page', type: 'int', default: 1, help: 'Result page number' }, { name: 'section', help: 'Forum section identifier' }, { name: 'sort', help: 'Sort order: relevance, latest, replies, views' }],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword); const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit'); const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page'); if (kwargs.sort && !SORTS.includes(String(kwargs.sort))) throw new ArgumentError(`--sort must be one of: ${SORTS.join(', ')}`);
+    await runBrowserStep('52pojie search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, section: kwargs.section, sort: kwargs.sort }))); await page.wait({ selector: '.forum-item, .search-list, .sltm', timeout: 8 }).catch(() => page.wait(2).catch(() => {})); const data = await runBrowserStep('52pojie search extraction', () => page.evaluate(`(${extractItems.toString()})()`));
+    if (data?.blocked) throw new CommandExecutionError('52pojie search was blocked by a verification page', 'Complete the verification in the browser and retry.'); if (!data?.items?.length) throw emptySearchResults('52pojie', keyword); return data.items.slice(0, limit).map((item, index) => ({ rank: (pageNumber - 1) * limit + index + 1, ...item }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/clis/baidu/search.js

@@ -0,0 +1,68 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireNonNegativeInteger, requireSearchQuery, runBrowserStep, toHttpsUrl } from '../_shared/search-adapter.js';
+
+const TYPES = ['web', 'news', 'image', 'video'];
+const FILETYPES = ['pdf', 'doc', 'xls', 'ppt', 'rtf', 'all'];
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, site, filetype, platform, time }) {
+  const url = new URL('https://www.baidu.com/s');
+  url.searchParams.set('wd', keyword);
+  url.searchParams.set('pn', String((page - 1) * limit));
+  if (site) url.searchParams.set('si', site);
+  if (filetype) url.searchParams.set('ft', filetype);
+  if (platform) url.searchParams.set('ie', platform === 'mobile' ? 'utf-8' : 'utf-8');
+  if (time) url.searchParams.set('gpc', `stf=${time}`);
+  return url.toString();
+}
+
+function validateChoice(value, choices, flag) {
+  if (value !== undefined && !choices.includes(String(value))) throw new ArgumentError(`--${flag} must be one of: ${choices.join(', ')}`);
+  return value === undefined ? undefined : String(value);
+}
+
+function extractItems() {
+  const blocked = /验证码|安全验证|百度安全验证|访问过于频繁|请完成验证/.test(document.body?.textContent || '');
+  const items = [];
+  const seen = new Set();
+  for (const card of document.querySelectorAll('.result, .c-container')) {
+    const anchor = card.querySelector('h3 a, h3 a[href]');
+    if (!anchor) continue;
+    const url = anchor.href || '';
+    if (!/^https?:/i.test(url) || seen.has(url)) continue;
+    seen.add(url);
+    items.push({ title: (anchor.textContent || '').trim(), url, snippet: (card.querySelector('.c-abstract, .content-right_8Zs40, .c-span-last')?.textContent || '').trim(), displayUrl: (card.querySelector('.c-showurl, .c-color-gray2')?.textContent || '').trim(), resultType: 'web', extra: {} });
+  }
+  return { blocked, items };
+}
+
+export const command = cli({
+  site: 'baidu', name: 'search', access: 'read', description: 'Search Baidu', domain: 'www.baidu.com', strategy: Strategy.PUBLIC, browser: true,
+  args: [
+    { name: 'keyword', positional: true, required: true, help: 'Search query' },
+    { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-50)' },
+    { name: 'page', type: 'int', default: 1, help: 'Result page number' },
+    { name: 'site', help: 'Restrict results to a domain' },
+    { name: 'filetype', help: 'File type: pdf, doc, xls, ppt, rtf, all' },
+    { name: 'platform', help: 'Client platform: pc or mobile' },
+    { name: 'time', help: 'Recent time filter understood by Baidu' },
+  ],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword);
+    const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit');
+    const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page');
+    const filetype = validateChoice(kwargs.filetype, FILETYPES, 'filetype');
+    const platform = validateChoice(kwargs.platform, ['pc', 'mobile'], 'platform');
+    const raw = await runBrowserStep('Baidu search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, site: kwargs.site, filetype, platform, time: kwargs.time })));
+    void raw;
+    await page.wait({ selector: '.result, .c-container', timeout: 8 }).catch(() => page.wait(2).catch(() => {}));
+    const data = await runBrowserStep('Baidu search extraction', () => page.evaluate(`(${extractItems.toString()})()`));
+    if (data?.blocked) throw new CommandExecutionError('Baidu search was blocked by a verification page', 'Complete the verification in the browser and retry.');
+    const items = data?.items || [];
+    if (!items.length) throw emptySearchResults('Baidu', keyword);
+    return items.slice(0, limit).map((item, index) => ({ rank: (pageNumber - 1) * limit + index + 1, ...item, source: 'baidu', author: null, publishedAt: null, score: null }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/clis/bing/search.js

@@ -0,0 +1,58 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireSearchQuery, runBrowserStep } from '../_shared/search-adapter.js';
+
+const FRESHNESS = ['day', 'week', 'month', 'year'];
+const ANSWERS = ['web', 'news', 'video', 'images'];
+const SAFE = ['off', 'moderate', 'strict'];
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, freshness, market, answer, safe }) {
+  const url = new URL('https://www.bing.com/search');
+  url.searchParams.set('q', keyword);
+  url.searchParams.set('count', String(limit));
+  url.searchParams.set('first', String((page - 1) * limit + 1));
+  if (freshness) url.searchParams.set('freshness', freshness);
+  if (market) url.searchParams.set('cc', String(market).split('-').pop().toUpperCase());
+  if (answer && answer !== 'web') url.searchParams.set('scope', answer);
+  if (safe) url.searchParams.set('safesearch', safe);
+  return url.toString();
+}
+
+function validate(value, choices, flag) {
+  if (value !== undefined && !choices.includes(String(value))) throw new ArgumentError(`--${flag} must be one of: ${choices.join(', ')}`);
+  return value === undefined ? undefined : String(value);
+}
+
+function extractItems() {
+  const blocked = /unusual traffic|verify you are human|captcha|access denied/i.test(document.body?.textContent || '');
+  const items = [];
+  const seen = new Set();
+  for (const card of document.querySelectorAll('li.b_algo')) {
+    const anchor = card.querySelector('h2 a[href]');
+    if (!anchor || !/^https?:/i.test(anchor.href) || seen.has(anchor.href)) continue;
+    seen.add(anchor.href);
+    items.push({ title: (anchor.textContent || '').trim(), url: anchor.href, snippet: (card.querySelector('.b_caption p')?.textContent || '').trim(), displayUrl: (card.querySelector('cite')?.textContent || '').trim(), resultType: 'web', extra: {} });
+  }
+  return { blocked, items };
+}
+
+export const command = cli({
+  site: 'bing', name: 'search', access: 'read', description: 'Search Bing', domain: 'www.bing.com', strategy: Strategy.PUBLIC, browser: true,
+  args: [
+    { name: 'keyword', positional: true, required: true, help: 'Search query' }, { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-50)' }, { name: 'page', type: 'int', default: 1, help: 'Result page number' },
+    { name: 'freshness', help: 'Time range: day, week, month, year' }, { name: 'market', help: 'Market code such as en-US or zh-CN' }, { name: 'answer', help: 'Result scope: web, news, video, images' }, { name: 'safe', help: 'Safe search: off, moderate, strict' },
+  ],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword); const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit'); const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page');
+    const freshness = validate(kwargs.freshness, FRESHNESS, 'freshness'); const answer = validate(kwargs.answer, ANSWERS, 'answer'); const safe = validate(kwargs.safe, SAFE, 'safe');
+    await runBrowserStep('Bing search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, freshness, market: kwargs.market, answer, safe })));
+    await page.wait({ selector: 'li.b_algo', timeout: 8 }).catch(() => page.wait(2).catch(() => {}));
+    const data = await runBrowserStep('Bing search extraction', () => page.evaluate(`(${extractItems.toString()})()`));
+    if (data?.blocked) throw new CommandExecutionError('Bing search was blocked by a verification page', 'Complete the verification in the browser and retry.');
+    if (!data?.items?.length) throw emptySearchResults('Bing', keyword);
+    return data.items.slice(0, limit).map((item, index) => ({ rank: (pageNumber - 1) * limit + index + 1, ...item, source: 'bing', author: null, publishedAt: null, score: null }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/clis/csdn/search.js

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireSearchQuery, runBrowserStep } from '../_shared/search-adapter.js';
+
+const TYPES = ['all', 'blog', 'download', 'course']; const SORTS = ['relevance', 'latest', 'hot']; const TIMES = ['day', 'week', 'month', 'year'];
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, contentType = 'all', sort, time }) {
+  const url = new URL('https://so.csdn.net/so/search'); url.searchParams.set('q', keyword); url.searchParams.set('p', String(page)); url.searchParams.set('t', contentType); url.searchParams.set('size', String(limit));
+  if (sort) url.searchParams.set('sort', sort); if (time) url.searchParams.set('time', time); return url.toString();
+}
+
+function extractItems() {
+  const blocked = /登录|验证码|访问异常|captcha|sign in/i.test(document.body?.textContent || '') && !document.querySelector('.search-result-info, .search-result'); const items = []; const seen = new Set();
+  for (const card of document.querySelectorAll('.search-result-info, .search-result')) {
+    const anchor = card.querySelector('h3 a[href], h4 a[href]'); if (!anchor || !/^https?:/i.test(anchor.href) || seen.has(anchor.href)) continue;
+    seen.add(anchor.href); const time = card.querySelector('time'); items.push({ rank: items.length + 1, title: (anchor.textContent || '').trim(), url: anchor.href, snippet: (card.querySelector('.search-result-desc, p')?.textContent || '').trim(), displayUrl: new URL(anchor.href).hostname + new URL(anchor.href).pathname, source: 'csdn', resultType: 'article', author: (card.querySelector('.author, .user-name')?.textContent || '').trim() || null, publishedAt: time?.getAttribute('datetime') || null, score: null, extra: {} });
+  }
+  return { blocked, items };
+}
+
+export const command = cli({
+  site: 'csdn', name: 'search', access: 'read', description: 'Search CSDN', domain: 'so.csdn.net', strategy: Strategy.PUBLIC, browser: true,
+  args: [{ name: 'keyword', positional: true, required: true, help: 'Search query' }, { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-50)' }, { name: 'page', type: 'int', default: 1, help: 'Result page number' }, { name: 'content-type', help: 'Content type: all, blog, download, course' }, { name: 'sort', help: 'Sort order: relevance, latest, hot' }, { name: 'time', help: 'Time range: day, week, month, year' }],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword); const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit'); const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page'); const contentType = kwargs['content-type'] ?? kwargs.contentType ?? 'all';
+    if (!TYPES.includes(String(contentType))) throw new ArgumentError(`--content-type must be one of: ${TYPES.join(', ')}`); if (kwargs.sort && !SORTS.includes(String(kwargs.sort))) throw new ArgumentError(`--sort must be one of: ${SORTS.join(', ')}`); if (kwargs.time && !TIMES.includes(String(kwargs.time))) throw new ArgumentError(`--time must be one of: ${TIMES.join(', ')}`);
+    await runBrowserStep('CSDN search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, contentType, sort: kwargs.sort, time: kwargs.time }))); await page.wait({ selector: '.search-result-info, .search-result', timeout: 8 }).catch(() => page.wait(2).catch(() => {}));
+    const data = await runBrowserStep('CSDN search extraction', () => page.evaluate(`(${extractItems.toString()})()`)); if (data?.blocked) throw new CommandExecutionError('CSDN search requires login or was blocked', 'Open CSDN in the browser, complete any prompt, and retry.'); if (!data?.items?.length) throw emptySearchResults('CSDN', keyword);
+    return data.items.slice(0, limit).map((item, index) => ({ ...item, rank: (pageNumber - 1) * limit + index + 1 }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/clis/gitlab/search.js

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireSearchQuery, runBrowserStep } from '../_shared/search-adapter.js';
+
+const SCOPES = ['projects', 'issues', 'merge_requests', 'commits', 'blobs', 'users'];
+const ORDER = ['created_at', 'updated_at', 'latest_activity_at']; const SORT = ['asc', 'desc'];
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, scope = 'projects', orderBy, sort }) {
+  const url = new URL('https://gitlab.com/search'); url.searchParams.set('search', keyword); url.searchParams.set('page', String(page)); url.searchParams.set('per_page', String(limit));
+  if (scope) url.searchParams.set('scope', scope); if (orderBy) url.searchParams.set('order_by', orderBy); if (sort) url.searchParams.set('sort', sort); return url.toString();
+}
+
+function extractItems(scope) {
+  const blocked = /sign in|login|access denied|captcha/i.test(document.body?.textContent || '') && !document.querySelector('.search-result-row, .search-results'); const items = []; const seen = new Set();
+  for (const card of document.querySelectorAll('.search-result-row, .search-result-item, .search-results li')) {
+    const anchor = card.querySelector('a.gl-link[href], a[href*="gitlab.com/"]'); if (!anchor || !/^https?:/i.test(anchor.href) || seen.has(anchor.href)) continue;
+    seen.add(anchor.href); const time = card.querySelector('time'); const type = scope === 'issues' ? 'issue' : scope === 'merge_requests' ? 'merge_request' : scope === 'projects' ? 'project' : scope || 'result';
+    items.push({ title: (anchor.textContent || '').trim(), url: anchor.href, snippet: (card.querySelector('.description, .description p, p')?.textContent || '').trim(), displayUrl: new URL(anchor.href).hostname + new URL(anchor.href).pathname, source: 'gitlab', resultType: type, author: (card.querySelector('.author, [data-testid="author"]')?.textContent || '').trim() || null, publishedAt: time?.getAttribute('datetime') || null, score: null, extra: {} });
+  }
+  return { blocked, items };
+}
+
+export const command = cli({
+  site: 'gitlab', name: 'search', access: 'read', description: 'Search GitLab', domain: 'gitlab.com', strategy: Strategy.PUBLIC, browser: true,
+  args: [{ name: 'keyword', positional: true, required: true, help: 'Search query' }, { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-50)' }, { name: 'page', type: 'int', default: 1, help: 'Result page number' }, { name: 'scope', help: 'Search scope: projects, issues, merge_requests, commits, blobs, users' }, { name: 'order-by', help: 'Order by: created_at, updated_at, latest_activity_at' }, { name: 'sort', help: 'Sort direction: asc or desc' }],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword); const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit'); const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page'); const scope = kwargs.scope || 'projects'; const orderBy = kwargs['order-by'] ?? kwargs.orderBy; const sort = kwargs.sort;
+    if (!SCOPES.includes(String(scope))) throw new ArgumentError(`--scope must be one of: ${SCOPES.join(', ')}`); if (orderBy && !ORDER.includes(String(orderBy))) throw new ArgumentError(`--order-by must be one of: ${ORDER.join(', ')}`); if (sort && !SORT.includes(String(sort))) throw new ArgumentError('--sort must be one of: asc, desc');
+    await runBrowserStep('GitLab search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, scope, orderBy, sort }))); await page.wait({ selector: '.search-result-row, .search-results', timeout: 8 }).catch(() => page.wait(2).catch(() => {}));
+    const data = await runBrowserStep('GitLab search extraction', () => page.evaluate(`(${extractItems.toString()})(${JSON.stringify(scope)})`)); if (data?.blocked) throw new CommandExecutionError('GitLab search requires sign-in or was blocked', 'Open GitLab in the browser, sign in if needed, and retry.'); if (!data?.items?.length) throw emptySearchResults('GitLab', keyword);
+    return data.items.slice(0, limit).map((item, index) => ({ rank: (pageNumber - 1) * limit + index + 1, ...item }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/clis/so/search.js

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireSearchQuery, runBrowserStep } from '../_shared/search-adapter.js';
+
+const TYPES = ['web', 'news', 'video', 'image']; const SAFE = ['off', 'on'];
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, type, safe }) {
+  const url = new URL('https://so.com/s'); url.searchParams.set('q', keyword); url.searchParams.set('pn', String(page)); url.searchParams.set('num', String(limit));
+  if (type && type !== 'web') url.searchParams.set('type', type); if (safe) url.searchParams.set('safe', safe); return url.toString();
+}
+
+function extractItems() {
+  const blocked = /验证码|安全验证|访问异常|captcha|access denied/i.test(document.body?.textContent || ''); const items = []; const seen = new Set();
+  for (const card of document.querySelectorAll('.result, .res-list')) {
+    if (/result-ad|ad-result|推广/.test(card.className || '') || /推广/.test(card.textContent || '')) continue;
+    const anchor = card.querySelector('h3 a[href], h2 a[href]'); if (!anchor || !/^https?:/i.test(anchor.href) || seen.has(anchor.href)) continue;
+    seen.add(anchor.href); items.push({ title: (anchor.textContent || '').trim(), url: anchor.href, snippet: (card.querySelector('.res-desc, .res-rich, p')?.textContent || '').trim(), displayUrl: (card.querySelector('cite, .res-link')?.textContent || '').trim(), resultType: 'web', extra: {} });
+  }
+  return { blocked, items };
+}
+
+export const command = cli({
+  site: 'so', name: 'search', access: 'read', description: 'Search 360 Search', domain: 'so.com', strategy: Strategy.PUBLIC, browser: true,
+  args: [{ name: 'keyword', positional: true, required: true, help: 'Search query' }, { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-50)' }, { name: 'page', type: 'int', default: 1, help: 'Result page number' }, { name: 'type', help: 'Result type: web, news, video, image' }, { name: 'safe', help: 'Safe search: off or on' }],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword); const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit'); const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page');
+    if (kwargs.type !== undefined && !TYPES.includes(String(kwargs.type))) throw new ArgumentError(`--type must be one of: ${TYPES.join(', ')}`); if (kwargs.safe !== undefined && !SAFE.includes(String(kwargs.safe))) throw new ArgumentError('--safe must be one of: off, on');
+    await runBrowserStep('360 search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, type: kwargs.type, safe: kwargs.safe })));
+    await page.wait({ selector: '.result, .res-list', timeout: 8 }).catch(() => page.wait(2).catch(() => {})); const data = await runBrowserStep('360 search extraction', () => page.evaluate(`(${extractItems.toString()})()`));
+    if (data?.blocked) throw new CommandExecutionError('360 Search was blocked by a verification page', 'Complete the verification in the browser and retry.'); if (!data?.items?.length) throw emptySearchResults('360 Search', keyword);
+    return data.items.slice(0, limit).map((item, index) => ({ rank: (pageNumber - 1) * limit + index + 1, ...item, source: 'so', author: null, publishedAt: null, score: null }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/clis/sogou/search.js

@@ -0,0 +1,35 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireSearchQuery, runBrowserStep } from '../_shared/search-adapter.js';
+
+const TYPES = ['web', 'news', 'video', 'image']; const TIMES = ['day', 'week', 'month', 'year']; const SORTS = ['relevance', 'date'];
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, type, time, sort }) {
+  const url = new URL('https://sogou.com/web'); url.searchParams.set('query', keyword); url.searchParams.set('num', String(limit)); url.searchParams.set('page', String(page));
+  if (type && type !== 'web') url.searchParams.set('type', type); if (time) url.searchParams.set('tsn', time); if (sort === 'date') url.searchParams.set('sort', 'time'); return url.toString();
+}
+
+function extractItems() {
+  const blocked = /验证码|安全验证|访问异常|请完成验证|captcha/i.test(document.body?.textContent || ''); const items = []; const seen = new Set();
+  for (const card of document.querySelectorAll('.vrwrap, .rb')) {
+    const anchor = card.querySelector('h3 a[href], h4 a[href]'); if (!anchor || !/^https?:/i.test(anchor.href) || seen.has(anchor.href)) continue;
+    if (/推广|广告/.test(card.textContent || '')) continue; seen.add(anchor.href); items.push({ title: (anchor.textContent || '').trim(), url: anchor.href, snippet: (card.querySelector('.str_info, .ft, .text-layout')?.textContent || '').trim(), displayUrl: (card.querySelector('cite, .citeurl')?.textContent || '').trim(), resultType: 'web', extra: {} });
+  }
+  return { blocked, items };
+}
+
+export const command = cli({
+  site: 'sogou', name: 'search', access: 'read', description: 'Search Sogou', domain: 'sogou.com', strategy: Strategy.PUBLIC, browser: true,
+  args: [{ name: 'keyword', positional: true, required: true, help: 'Search query' }, { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-50)' }, { name: 'page', type: 'int', default: 1, help: 'Result page number' }, { name: 'type', help: 'Result type: web, news, video, image' }, { name: 'time', help: 'Time range: day, week, month, year' }, { name: 'sort', help: 'Sort order: relevance or date' }],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword); const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit'); const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page');
+    for (const [value, choices, flag] of [[kwargs.type, TYPES, 'type'], [kwargs.time, TIMES, 'time'], [kwargs.sort, SORTS, 'sort']]) if (value !== undefined && !choices.includes(String(value))) throw new ArgumentError(`--${flag} must be one of: ${choices.join(', ')}`);
+    await runBrowserStep('Sogou search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, type: kwargs.type, time: kwargs.time, sort: kwargs.sort })));
+    await page.wait({ selector: '.vrwrap, .rb', timeout: 8 }).catch(() => page.wait(2).catch(() => {})); const data = await runBrowserStep('Sogou search extraction', () => page.evaluate(`(${extractItems.toString()})()`));
+    if (data?.blocked) throw new CommandExecutionError('Sogou search was blocked by a verification page', 'Complete the verification in the browser and retry.'); if (!data?.items?.length) throw emptySearchResults('Sogou', keyword);
+    return data.items.slice(0, limit).map((item, index) => ({ rank: (pageNumber - 1) * limit + index + 1, ...item, source: 'sogou', author: null, publishedAt: null, score: null }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/clis/threads/search.js

@@ -0,0 +1,33 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireSearchQuery, runBrowserStep } from '../_shared/search-adapter.js';
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, author, since, until }) {
+  const url = new URL('https://www.threads.com/search'); url.searchParams.set('q', keyword); url.searchParams.set('limit', String(limit)); url.searchParams.set('page', String(page));
+  if (author) url.searchParams.set('author', String(author).replace(/^@+/, '')); if (since) url.searchParams.set('since', since); if (until) url.searchParams.set('until', until); return url.toString();
+}
+
+function extractItems() {
+  const body = document.body?.textContent || ''; const authRequired = /log in|sign up|登录|注册/i.test(body) && !document.querySelector('article[data-pressable-container], article'); const blocked = /captcha|unusual activity|try again later|暂时无法/i.test(body); const items = []; const seen = new Set();
+  for (const card of document.querySelectorAll('article[data-pressable-container], article')) {
+    const anchor = card.querySelector('a[href*="/post/"]'); if (!anchor || !/^https?:/i.test(anchor.href) || seen.has(anchor.href)) continue; seen.add(anchor.href);
+    const authorAnchor = card.querySelector('a[href^="/@"], a[href*="/@"]'); const author = (authorAnchor?.textContent || authorAnchor?.getAttribute('href') || '').trim().replace(/^@+/, '').replace(/^\//, '').split('/')[0] || null; const time = card.querySelector('time');
+    items.push({ title: (card.querySelector('.text, [data-pressable-container] div')?.textContent || card.textContent || '').trim().slice(0, 500), url: anchor.href, snippet: (card.textContent || '').trim().slice(0, 500), displayUrl: new URL(anchor.href).hostname + new URL(anchor.href).pathname, source: 'threads', resultType: 'post', author, publishedAt: time?.getAttribute('datetime') || null, score: null, extra: {} });
+  }
+  return { authRequired, blocked, items };
+}
+
+export const command = cli({
+  site: 'threads', name: 'search', access: 'read', description: 'Search Threads', domain: 'www.threads.com', strategy: Strategy.PUBLIC, browser: true,
+  args: [{ name: 'keyword', positional: true, required: true, help: 'Search query' }, { name: 'limit', type: 'int', default: 10, help: 'Number of posts (1-50)' }, { name: 'page', type: 'int', default: 1, help: 'Result page number' }, { name: 'author', help: 'Filter by author handle' }, { name: 'since', help: 'Only posts on or after YYYY-MM-DD' }, { name: 'until', help: 'Only posts on or before YYYY-MM-DD' }],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword); const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit'); const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page');
+    for (const [value, flag] of [[kwargs.since, 'since'], [kwargs.until, 'until']]) if (value !== undefined && !/^\d{4}-\d{2}-\d{2}$/.test(String(value))) throw new ArgumentError(`--${flag} must use YYYY-MM-DD format`);
+    await runBrowserStep('Threads search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, author: kwargs.author, since: kwargs.since, until: kwargs.until }))); await page.wait({ selector: 'article', timeout: 8 }).catch(() => page.wait(2).catch(() => {}));
+    const data = await runBrowserStep('Threads search extraction', () => page.evaluate(`(${extractItems.toString()})()`)); if (data?.authRequired) throw new AuthRequiredError('Threads search requires login', 'Open Threads in the browser and sign in before retrying.'); if (data?.blocked) throw new CommandExecutionError('Threads search was blocked by an anti-bot page', 'Complete the browser prompt and retry.'); if (!data?.items?.length) throw emptySearchResults('Threads', keyword);
+    return data.items.slice(0, limit).map((item, index) => ({ rank: (pageNumber - 1) * limit + index + 1, ...item }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/clis/toutiao/search.js

@@ -0,0 +1,63 @@
+/**
+ * Toutiao public site search — extracts rich result cards from the rendered
+ * public search page. No authentication required.
+ */
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
+import { parseSearchLimit, parseSearchType, parseToutiaoSearchHtml, TOUTIAO_SEARCH_URL } from './utils.js';
+
+cli({
+    site: 'toutiao',
+    name: 'search',
+    access: 'read',
+    description: '搜索今日头条公开站内内容',
+    domain: 'www.toutiao.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', type: 'string', positional: true, help: '搜索关键词' },
+        { name: 'type', type: 'string', default: 'synthesis', help: '搜索类型 (synthesis/information/video/atlas/user/xiaoshipin/weitoutiao/music)' },
+        { name: 'limit', type: 'int', default: 20, help: '返回条数 (1-50)' },
+    ],
+    columns: [
+        'rank', 'title', 'url', 'source', 'publish_time', 'summary', 'image_url',
+        'like_count', 'comment_count', 'share_count', 'read_count',
+    ],
+    func: async (_page, kwargs) => {
+        const query = String(kwargs?.query ?? '').trim();
+        if (!query) throw new CommandExecutionError('toutiao search requires a non-empty query');
+        const type = parseSearchType(kwargs?.type, 'synthesis');
+        const limit = parseSearchLimit(kwargs?.limit, 20);
+        const url = new URL(TOUTIAO_SEARCH_URL);
+        url.searchParams.set('keyword', query);
+        url.searchParams.set('pd', type);
+        url.searchParams.set('page_num', '0');
+
+        let resp;
+        try {
+            resp = await fetch(url, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+                    Accept: 'text/html,application/xhtml+xml',
+                    Referer: 'https://www.toutiao.com/',
+                },
+            });
+        } catch (error) {
+            throw new CommandExecutionError(`toutiao search request failed: ${error?.message || error}`);
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`toutiao search failed: HTTP ${resp.status}`);
+        }
+        let html;
+        try {
+            html = await resp.text();
+        } catch (error) {
+            throw new CommandExecutionError(`toutiao search response read failed: ${error?.message || error}`);
+        }
+        const rows = parseToutiaoSearchHtml(html, limit);
+        if (rows.length === 0) {
+            throw new EmptyResultError('toutiao search', `未找到与「${query}」相关的公开内容。`);
+        }
+        return rows;
+    },
+});

package/clis/toutiao/utils.js

@@ -7,6 +7,9 @@ const ARTICLES_MIN_PAGE = 1;
 const ARTICLES_MAX_PAGE = 4;
 const HOT_MIN_LIMIT = 1;
 const HOT_MAX_LIMIT = 50;
+const SEARCH_MIN_LIMIT = 1;
+const SEARCH_MAX_LIMIT = 50;
+const SEARCH_TYPES = ['synthesis', 'information', 'video', 'atlas', 'user', 'xiaoshipin', 'weitoutiao', 'music'];
 
 export function parseArticlesPage(raw, fallback = 1) {
     if (raw === undefined || raw === null || raw === '') return fallback;
@@ -32,6 +35,27 @@ export function parseHotLimit(raw, fallback = 30) {
     return parsed;
 }
 
+export function parseSearchLimit(raw, fallback = 20) {
+    if (raw === undefined || raw === null || raw === '') return fallback;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be an integer between ${SEARCH_MIN_LIMIT} and ${SEARCH_MAX_LIMIT}, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < SEARCH_MIN_LIMIT || parsed > SEARCH_MAX_LIMIT) {
+        throw new ArgumentError(`--limit must be between ${SEARCH_MIN_LIMIT} and ${SEARCH_MAX_LIMIT}, got ${parsed}`);
+    }
+    return parsed;
+}
+
+export function parseSearchType(raw, fallback = 'synthesis') {
+    if (raw === undefined || raw === null || raw === '') return fallback;
+    const value = String(raw).trim();
+    if (!SEARCH_TYPES.includes(value)) {
+        throw new ArgumentError(`--type must be one of ${SEARCH_TYPES.join(', ')}, got ${JSON.stringify(raw)}`);
+    }
+    return value;
+}
+
 const NON_TITLE_LINES = new Set([
     '展现', '阅读', '点赞', '评论',
     '查看数据', '查看评论', '修改', '更多', '首发',
@@ -149,6 +173,83 @@ export function mapHotRow(item, index) {
 }
 
 export const HOT_BOARD_URL = 'https://www.toutiao.com/hot-event/hot-board/?origin=toutiao_pc';
+export const TOUTIAO_SEARCH_URL = 'https://www.toutiao.com/search/';
+
+function parseSearchNumber(value) {
+    if (value === undefined || value === null || value === '') return null;
+    const parsed = Number(String(value).replace(/,/g, ''));
+    return Number.isFinite(parsed) && parsed >= 0 ? Math.trunc(parsed) : null;
+}
+
+function absoluteSearchUrl(value) {
+    const url = trimOrNull(value);
+    if (!url) return null;
+    try {
+        return new URL(url, 'https://www.toutiao.com/').toString();
+    } catch {
+        return null;
+    }
+}
+
+function searchImage(item) {
+    const candidates = [
+        item?.image_url,
+        item?.large_image_url,
+        item?.other_image_url,
+        ...(Array.isArray(item?.image_list) ? item.image_list.map((image) => image?.url || image) : []),
+        ...(Array.isArray(item?.detail_image_list) ? item.detail_image_list.map((image) => image?.url || image) : []),
+    ];
+    return candidates.map(trimOrNull).find(Boolean) || null;
+}
+
+function searchRowFromCard(item, index) {
+    if (!item || typeof item !== 'object') return null;
+    const title = trimOrNull(item.title);
+    const url = absoluteSearchUrl(
+        item.article_url || item.open_url || item.source_url || item.item_source_url || item?.display?.info?.url,
+    );
+    if (!title || !url) return null;
+    return {
+        rank: index + 1,
+        title,
+        url,
+        source: trimOrNull(item.source || item.media_name),
+        publish_time: trimOrNull(item.datetime || item.publish_time || item.display_time),
+        summary: trimOrNull(item.abstract || item.summary || item?.emphasized?.summary),
+        image_url: searchImage(item),
+        like_count: parseSearchNumber(item.like_count ?? item.digg_count),
+        comment_count: parseSearchNumber(item.comment_count),
+        share_count: parseSearchNumber(item.share_count ?? item.repin_count ?? item.forward_count),
+        read_count: parseSearchNumber(item.read_count),
+    };
+}
+
+/**
+ * Extract search result cards embedded in the public Toutiao search page.
+ * The page currently serializes each result as an application/json script.
+ */
+export function parseToutiaoSearchHtml(html, limit = 20) {
+    const source = String(html || '');
+    const rows = [];
+    const seenUrls = new Set();
+    const scriptPattern = /<script\b[^>]*type=["']application\/json["'][^>]*>([\s\S]*?)<\/script>/gi;
+    let match;
+    while ((match = scriptPattern.exec(source))) {
+        let payload;
+        try {
+            payload = JSON.parse(match[1]);
+        } catch {
+            continue;
+        }
+        const candidate = payload?.data;
+        const row = searchRowFromCard(candidate, rows.length);
+        if (!row || seenUrls.has(row.url)) continue;
+        seenUrls.add(row.url);
+        rows.push(row);
+        if (rows.length >= limit) break;
+    }
+    return rows.map((row, index) => ({ ...row, rank: index + 1 }));
+}
 
 export function looksToutiaoAuthWallText(value) {
     const text = String(value || '').replace(/\s+/g, ' ').trim().toLowerCase();
@@ -158,4 +259,12 @@ export function looksToutiaoAuthWallText(value) {
         /mp\.toutiao\.com\/profile_v4\/login/.test(text);
 }
 
-export const __test__ = { ARTICLES_MIN_PAGE, ARTICLES_MAX_PAGE, HOT_MIN_LIMIT, HOT_MAX_LIMIT };
+export const __test__ = {
+    ARTICLES_MIN_PAGE,
+    ARTICLES_MAX_PAGE,
+    HOT_MIN_LIMIT,
+    HOT_MAX_LIMIT,
+    SEARCH_MIN_LIMIT,
+    SEARCH_MAX_LIMIT,
+    SEARCH_TYPES,
+};

package/clis/yandex/search.js

@@ -0,0 +1,43 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
+import { emptySearchResults, requireBoundedInteger, requireSearchQuery, runBrowserStep } from '../_shared/search-adapter.js';
+
+const SORTS = ['relevance', 'date'];
+
+export function buildSearchUrl({ keyword, limit = 10, page = 1, lr, lang, sort }) {
+  const url = new URL('https://yandex.com/search/');
+  url.searchParams.set('text', keyword); url.searchParams.set('numdoc', String(limit)); url.searchParams.set('p', String(page - 1));
+  if (lr) url.searchParams.set('lr', lr); if (lang) url.searchParams.set('lang', lang); if (sort === 'date') url.searchParams.set('how', 'tm');
+  return url.toString();
+}
+
+function extractItems() {
+  const blocked = /captcha|verify|access denied|consent/i.test(document.body?.textContent || '') && !document.querySelector('.serp-item');
+  const items = []; const seen = new Set();
+  for (const card of document.querySelectorAll('.serp-item')) {
+    const anchor = card.querySelector('h2 a[href], .OrganicTitle a[href]'); if (!anchor || !/^https?:/i.test(anchor.href) || seen.has(anchor.href)) continue;
+    seen.add(anchor.href); items.push({ title: (anchor.textContent || '').trim(), url: anchor.href, snippet: (card.querySelector('.OrganicText, .TextContainer')?.textContent || '').trim(), displayUrl: (card.querySelector('.Path, .OrganicUrl')?.textContent || '').trim(), resultType: 'web', extra: {} });
+  }
+  return { blocked, items };
+}
+
+export const command = cli({
+  site: 'yandex', name: 'search', access: 'read', description: 'Search Yandex', domain: 'yandex.com', strategy: Strategy.PUBLIC, browser: true,
+  args: [
+    { name: 'keyword', positional: true, required: true, help: 'Search query' }, { name: 'limit', type: 'int', default: 10, help: 'Number of results (1-50)' }, { name: 'page', type: 'int', default: 1, help: 'Result page number' },
+    { name: 'lr', help: 'Yandex region code' }, { name: 'lang', help: 'Language code' }, { name: 'sort', help: 'Sort order: relevance or date' },
+  ],
+  columns: ['rank', 'title', 'url', 'snippet', 'displayUrl', 'source', 'resultType', 'author', 'publishedAt', 'score', 'extra'],
+  func: async (page, kwargs) => {
+    const keyword = requireSearchQuery(kwargs.keyword); const limit = requireBoundedInteger(kwargs.limit, 10, 1, 50, '--limit'); const pageNumber = requireBoundedInteger(kwargs.page, 1, 1, 100, '--page');
+    if (kwargs.sort !== undefined && !SORTS.includes(String(kwargs.sort))) throw new ArgumentError('--sort must be one of: relevance, date');
+    await runBrowserStep('Yandex search navigation', () => page.goto(buildSearchUrl({ keyword, limit, page: pageNumber, lr: kwargs.lr, lang: kwargs.lang, sort: kwargs.sort })));
+    await page.wait({ selector: '.serp-item', timeout: 8 }).catch(() => page.wait(2).catch(() => {}));
+    const data = await runBrowserStep('Yandex search extraction', () => page.evaluate(`(${extractItems.toString()})()`));
+    if (data?.blocked) throw new CommandExecutionError('Yandex search was blocked by a consent or verification page', 'Complete the page prompt in the browser and retry.');
+    if (!data?.items?.length) throw emptySearchResults('Yandex', keyword);
+    return data.items.slice(0, limit).map((item, index) => ({ rank: (pageNumber - 1) * limit + index + 1, ...item, source: 'yandex', author: null, publishedAt: null, score: null }));
+  },
+});
+
+export const __test__ = { command, buildSearchUrl };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sovovs/bycli",
-  "version": "2.1.36",
+  "version": "2.1.38",
   "publishConfig": {
     "access": "public"
   },