@sovovs/bycli 2.1.37 → 2.1.39

package/clis/ima/knowledge.js

@@ -0,0 +1,95 @@
+import { cli, Strategy } from '@sovovs/bycli/registry';
+import {
+    ArgumentError,
+    CommandExecutionError,
+    ConfigError,
+    EmptyResultError,
+} from '@sovovs/bycli/errors';
+
+import { readKnowledgeBaseFromChrome } from './native-client.js';
+import { toKnowledgeRow } from './utils.js';
+
+const COMMAND = 'ima knowledge';
+
+function throwDriverError(envelope) {
+    const message = envelope?.message || 'ima reader failed';
+    switch (envelope?.code) {
+        case 'EMPTY_QUERY':
+        case 'AMBIGUOUS_KNOWLEDGE':
+            throw new ArgumentError(message);
+        case 'KNOWLEDGE_NOT_FOUND':
+            throw new EmptyResultError(COMMAND, message);
+        case 'IMA_CHROME_AUTH_REQUIRED':
+            throw new ConfigError(
+                message,
+                'Open https://ima.qq.com/wikis in Chrome, sign in, then retry with the latest bycli Browser Bridge extension.',
+            );
+        default:
+            throw new CommandExecutionError(message);
+    }
+}
+
+export async function runKnowledgeCommand(kwargs, read) {
+    const query = String(kwargs?.knowledgeBase ?? '').trim();
+    if (!query) {
+        throw new ArgumentError('knowledge-base name or ID is required');
+    }
+
+    let envelope;
+    try {
+        envelope = await read(query);
+    } catch (error) {
+        if (error instanceof ArgumentError || error instanceof ConfigError
+            || error instanceof EmptyResultError || error instanceof CommandExecutionError) {
+            throw error;
+        }
+        if (error && typeof error === 'object' && typeof error.code === 'string') {
+            throwDriverError({ code: error.code, message: error.message });
+        }
+        throw new CommandExecutionError(
+            `ima knowledge reader failed: ${error instanceof Error ? error.message : String(error)}`,
+        );
+    }
+    if (!envelope?.ok) throwDriverError(envelope);
+    if (!Array.isArray(envelope.items)) {
+        throw new CommandExecutionError('ima knowledge reader returned malformed items');
+    }
+    if (envelope.items.length === 0) {
+        throw new EmptyResultError(COMMAND, `Knowledge base "${query}" contains no readable articles.`);
+    }
+    return envelope.items.map(toKnowledgeRow);
+}
+
+export const knowledgeCommand = cli({
+    site: 'ima',
+    name: 'knowledge',
+    access: 'read',
+    description: '按名称或 ID 获取 ima 知识库中的文章标题、URL 与文件夹路径',
+    domain: 'ima.qq.com',
+    defaultFormat: 'json',
+    args: [
+        {
+            name: 'knowledgeBase',
+            type: 'string',
+            required: true,
+            positional: true,
+            help: '知识库的完整名称或 ima 页面中的 knowledgeBaseId',
+        },
+    ],
+    columns: [
+        'knowledgeBaseId',
+        'knowledgeBase',
+        'folderPath',
+        'title',
+        'url',
+        'contentType',
+        'addedDate',
+    ],
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    func: async (page, kwargs) => runKnowledgeCommand(
+        kwargs,
+        (query) => readKnowledgeBaseFromChrome(page, query),
+    ),
+});

package/clis/ima/native-api.js

@@ -0,0 +1,169 @@
+const MEDIA_TYPE_NAMES = new Map([
+    [0, '未知'], [1, 'PDF'], [2, '网址'], [3, 'WORD'], [4, 'PPT'],
+    [5, 'EXCEL'], [6, '公众号'], [7, 'MD'], [9, '图片'], [11, '笔记'],
+    [12, '问答'], [13, 'TXT'], [14, 'XMIND'], [15, '音频'], [16, '视频网站'],
+    [19, '播客'], [20, 'HTML'], [21, 'EPUB'], [98, '源代码'], [99, '文件夹'],
+]);
+function field(value, camelName, snakeName) {
+    return value?.[camelName] ?? value?.[snakeName];
+}
+
+function codedError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+
+function knowledgeBaseFromRaw(raw) {
+    const basicInfo = field(raw, 'basicInfo', 'basic_info') || {};
+    return {
+        id: String(field(raw, 'id', 'id') || ''),
+        name: String(field(basicInfo, 'name', 'name') || ''),
+    };
+}
+
+function basesFromGroups(response) {
+    const groups = field(response, 'results', 'results');
+    if (!Array.isArray(groups)) throw new Error('ima API returned malformed knowledge-base groups');
+    return groups.flatMap((group) => {
+        const list = field(group, 'knowledgeBaseList', 'knowledge_base_list');
+        return Array.isArray(list) ? list.map(knowledgeBaseFromRaw) : [];
+    });
+}
+
+export async function findKnowledgeBase(query, request) {
+    const initialGroups = [
+        { type: 1001, limit: 20 },
+        { type: 1002, limit: 20 },
+        { type: 1004, limit: 20 },
+        { type: 1005, limit: 50 },
+    ];
+    let response = await request('/get_knowledge_base_list', {
+        params: initialGroups.map(({ type, limit }) => ({ type, cursor: '', limit })),
+    });
+    const all = [];
+    const pendingPages = [];
+    const queuedPages = new Set();
+
+    for (;;) {
+        if (Number(response?.code) !== 0) {
+            throw new Error(response?.msg || `ima API error ${response?.code ?? 'unknown'}`);
+        }
+        all.push(...basesFromGroups(response));
+        const groups = field(response, 'results', 'results');
+        for (const group of groups) {
+            const cursor = field(group, 'nextCursor', 'next_cursor');
+            if (field(group, 'isEnd', 'is_end') === false) {
+                const type = Number(field(group, 'type', 'type'));
+                if (!cursor) {
+                    throw new Error(`ima API returned a missing cursor for knowledge-base group ${type}`);
+                }
+                const pageKey = `${type}:${cursor}`;
+                if (queuedPages.has(pageKey)) {
+                    throw new Error(`ima API returned a repeated cursor for knowledge-base group ${type}`);
+                }
+                queuedPages.add(pageKey);
+                pendingPages.push({
+                    type,
+                    cursor: String(cursor),
+                    limit: 10,
+                });
+            }
+        }
+        const next = pendingPages.shift();
+        if (!next) break;
+        response = await request('/get_knowledge_base_list', {
+            params: [next],
+        });
+    }
+
+    const matches = all.filter((base) => base.id === query || base.name === query);
+    if (matches.length === 0) {
+        throw codedError('KNOWLEDGE_NOT_FOUND', `Knowledge base "${query}" was not found`);
+    }
+    const unique = [...new Map(matches.map((base) => [base.id, base])).values()];
+    if (unique.length > 1) {
+        throw codedError('AMBIGUOUS_KNOWLEDGE', `Knowledge base name "${query}" is ambiguous`);
+    }
+    return unique[0];
+}
+
+function articleFromRaw(raw, knowledgeBaseId, knowledgeBaseName, folderPath) {
+    const mediaType = Number(field(raw, 'mediaType', 'media_type') ?? 0);
+    const jumpUrl = field(raw, 'jumpUrl', 'jump_url');
+    const sourcePath = field(raw, 'sourcePath', 'source_path');
+    return {
+        knowledgeBaseId,
+        knowledgeBase: knowledgeBaseName,
+        folderPath,
+        title: field(raw, 'title', 'title') || '',
+        url: jumpUrl || (/^https?:\/\//i.test(sourcePath || '') ? sourcePath : null),
+        contentType: MEDIA_TYPE_NAMES.get(mediaType) ?? String(mediaType),
+        addedDate: field(raw, 'timeWording', 'time_wording')
+            || field(raw, 'createTime', 'create_time')
+            || null,
+    };
+}
+
+export async function collectKnowledgeTree({ knowledgeBaseId, knowledgeBaseName, request }) {
+    const articles = [];
+    const pendingFolders = [{ id: '', path: [] }];
+    const visitedFolders = new Set();
+
+    while (pendingFolders.length > 0) {
+        const folder = pendingFolders.shift();
+        if (visitedFolders.has(folder.id)) continue;
+        visitedFolders.add(folder.id);
+        let cursor = '';
+        const visitedCursors = new Set();
+
+        do {
+            if (visitedCursors.has(cursor)) {
+                throw new Error(`ima API returned a repeated cursor for folder ${folder.id || 'root'}`);
+            }
+            visitedCursors.add(cursor);
+            const response = await request('/get_knowledge_list', {
+                cursor,
+                limit: 20,
+                knowledge_base_id: knowledgeBaseId,
+                need_default_cover: true,
+                ...(folder.id ? { folder_id: folder.id } : {}),
+                ext_info: { share_id: '' },
+            });
+            if (Number(response?.code) !== 0) {
+                throw new Error(response?.msg || `ima API error ${response?.code ?? 'unknown'}`);
+            }
+
+            const items = field(response, 'knowledgeList', 'knowledge_list');
+            if (!Array.isArray(items)) throw new Error('ima API returned malformed knowledge_list');
+            for (const item of items) {
+                const mediaType = Number(field(item, 'mediaType', 'media_type') ?? 0);
+                if (mediaType === 99) {
+                    const info = field(item, 'folderInfo', 'folder_info') || {};
+                    const id = field(info, 'folderId', 'folder_id');
+                    const name = field(info, 'name', 'name');
+                    if (id && name) pendingFolders.push({ id, path: [...folder.path, name] });
+                    continue;
+                }
+                articles.push(articleFromRaw(item, knowledgeBaseId, knowledgeBaseName, folder.path));
+            }
+
+            const isEnd = field(response, 'isEnd', 'is_end') !== false;
+            cursor = String(field(response, 'nextCursor', 'next_cursor') || '');
+            if (!isEnd && !cursor) {
+                throw new Error(`ima API returned a missing cursor for folder ${folder.id || 'root'}`);
+            }
+            if (isEnd) cursor = '';
+        } while (cursor);
+    }
+
+    return articles;
+}
+
+export async function readKnowledgeBaseFromApi(query, request) {
+    const knowledgeBase = await findKnowledgeBase(query, request);
+    const items = await collectKnowledgeTree({
+        knowledgeBaseId: knowledgeBase.id,
+        knowledgeBaseName: knowledgeBase.name,
+        request,
+    });
+    return { ok: true, items };
+}

package/clis/ima/native-client.js

@@ -0,0 +1,70 @@
+import { readKnowledgeBaseFromApi } from './native-api.js';
+
+const IMA_WIKIS_URL = 'https://ima.qq.com/wikis';
+
+function codedError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+
+const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+
+async function waitForImaAuth(page, timeoutMs, sleep) {
+    const deadline = Date.now() + timeoutMs;
+    do {
+        const auth = await page.readImaAuth();
+        if (auth?.authId) return auth.authId;
+        if (Date.now() >= deadline) break;
+        await sleep(Math.min(250, Math.max(1, deadline - Date.now())));
+    } while (true);
+    throw codedError(
+        'IMA_CHROME_AUTH_REQUIRED',
+        'ima reader authentication was not observed in the Chrome session',
+    );
+}
+
+async function triggerImaAuthRequest(page, query) {
+    await page.evaluate((knowledgeBase) => {
+        const candidates = [...document.querySelectorAll('._knowledgeListItem_xfmpc_1')];
+        const target = candidates.find((element) => element.innerText?.trim() === knowledgeBase)
+            ?? candidates[0];
+        if (!target) return false;
+        target.click();
+        return true;
+    }, query);
+}
+
+export async function readKnowledgeBaseFromChrome(page, query, dependencies = {}) {
+    if (!page || typeof page.startImaAuthCapture !== 'function'
+        || typeof page.readImaAuth !== 'function' || typeof page.requestImaReader !== 'function'
+        || typeof page.evaluate !== 'function') {
+        throw codedError(
+            'IMA_CHROME_AUTH_REQUIRED',
+            'The installed bycli Browser Bridge does not support private ima reader authentication',
+        );
+    }
+    const timeoutMs = dependencies.timeoutMs ?? 30_000;
+    const sleep = dependencies.sleep ?? wait;
+    let authId;
+    try {
+        await page.startImaAuthCapture();
+        await page.goto(IMA_WIKIS_URL);
+        await triggerImaAuthRequest(page, query);
+        authId = await waitForImaAuth(page, timeoutMs, sleep);
+    } catch (error) {
+        if (error?.code === 'IMA_CHROME_AUTH_REQUIRED') throw error;
+        throw codedError(
+            'IMA_CHROME_AUTH_REQUIRED',
+            `Chrome Browser Bridge could not acquire ima reader authentication: ${error instanceof Error ? error.message : String(error)}`,
+        );
+    }
+    try {
+        return await readKnowledgeBaseFromApi(
+            query,
+            (path, body) => page.requestImaReader(authId, path, body),
+        );
+    } finally {
+        if (typeof page.releaseImaAuth === 'function') {
+            await page.releaseImaAuth(authId).catch(() => {});
+        }
+    }
+}

package/clis/ima/utils.js

@@ -0,0 +1,48 @@
+const VOLATILE_QUERY_KEYS = new Set([
+    'sessionid',
+    'pass_ticket',
+    'exportkey',
+    'scene',
+    'ascene',
+    'devicetype',
+    'version',
+    'nettype',
+    'abtest_cookie',
+    'lang',
+    'countrycode',
+    'fontscale',
+    'wx_header',
+]);
+
+export function normalizeArticleUrl(value) {
+    if (typeof value !== 'string' || !value.trim()) return null;
+
+    try {
+        const raw = value.trim();
+        const parsed = new URL(raw.includes('://') ? raw : `https://${raw}`);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
+
+        parsed.hash = '';
+        for (const key of [...parsed.searchParams.keys()]) {
+            const normalizedKey = key.toLowerCase();
+            if (VOLATILE_QUERY_KEYS.has(normalizedKey) || normalizedKey.startsWith('utm_')) {
+                parsed.searchParams.delete(key);
+            }
+        }
+        return parsed.toString();
+    } catch {
+        return null;
+    }
+}
+
+export function toKnowledgeRow(item) {
+    return {
+        knowledgeBaseId: item.knowledgeBaseId || null,
+        knowledgeBase: item.knowledgeBase,
+        folderPath: Array.isArray(item.folderPath) ? item.folderPath : [],
+        title: item.title,
+        url: normalizeArticleUrl(item.url),
+        contentType: item.contentType || null,
+        addedDate: item.addedDate || null,
+    };
+}

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/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/dist/src/browser/daemon-client.d.ts

@@ -5,7 +5,7 @@
  */
 export interface DaemonCommand {
     id: string;
-    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'set-file-input' | 'insert-text' | 'bind' | 'network-capture-start' | 'network-capture-read' | 'wait-download' | 'cdp' | 'frames';
+    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'set-file-input' | 'insert-text' | 'bind' | 'network-capture-start' | 'network-capture-read' | 'ima-auth-start' | 'ima-auth-read' | 'ima-reader-request' | 'ima-auth-release' | 'wait-download' | 'cdp' | 'frames';
     /** Target page identity (targetId). Cross-layer contract with the extension. */
     page?: string;
     code?: string;
@@ -32,6 +32,9 @@ export interface DaemonCommand {
     text?: string;
     /** URL substring filter pattern for network capture */
     pattern?: string;
+    authId?: string;
+    readerPath?: string;
+    readerBody?: Record<string, unknown>;
     /** Download wait timeout in milliseconds */
     timeoutMs?: number;
     cdpMethod?: string;

package/dist/src/browser/page.d.ts

@@ -58,6 +58,12 @@ export declare class Page extends BasePage {
     screenshot(options?: ScreenshotOptions): Promise<string>;
     startNetworkCapture(pattern?: string): Promise<boolean>;
     readNetworkCapture(): Promise<unknown[]>;
+    startImaAuthCapture(): Promise<void>;
+    readImaAuth(): Promise<{
+        authId: string;
+    } | null>;
+    requestImaReader(authId: string, path: string, body: Record<string, unknown>): Promise<unknown>;
+    releaseImaAuth(authId: string): Promise<void>;
     waitForDownload(pattern?: string, timeoutMs?: number, options?: BrowserDownloadWaitOptions): Promise<BrowserDownloadWaitResult>;
     /**
      * Set local file paths on a file input element via CDP DOM.setFileInputFiles.

package/dist/src/browser/page.js

@@ -305,6 +305,26 @@ export class Page extends BasePage {
             return [];
         }
     }
+    async startImaAuthCapture() {
+        await sendCommand('ima-auth-start', this._cmdOpts());
+    }
+    async readImaAuth() {
+        const result = await sendCommand('ima-auth-read', this._cmdOpts());
+        if (!result || typeof result !== 'object' || typeof result.authId !== 'string')
+            return null;
+        return { authId: result.authId };
+    }
+    async requestImaReader(authId, path, body) {
+        return sendCommand('ima-reader-request', {
+            authId,
+            readerPath: path,
+            readerBody: body,
+            ...this._cmdOpts(),
+        });
+    }
+    async releaseImaAuth(authId) {
+        await sendCommand('ima-auth-release', { authId, ...this._cmdOpts() });
+    }
     async waitForDownload(pattern = '', timeoutMs = 30_000, options) {
         const result = await sendCommand('wait-download', {
             pattern,

package/dist/src/types.d.ts

@@ -203,6 +203,12 @@ export interface IPage {
     annotatedScreenshot?(options?: ScreenshotOptions): Promise<string>;
     startNetworkCapture?(pattern?: string): Promise<boolean>;
     readNetworkCapture?(): Promise<unknown[]>;
+    startImaAuthCapture?(): Promise<void>;
+    readImaAuth?(): Promise<{
+        authId: string;
+    } | null>;
+    requestImaReader?(authId: string, path: string, body: Record<string, unknown>): Promise<unknown>;
+    releaseImaAuth?(authId: string): Promise<void>;
     /**
      * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
      * Chrome reads the files directly — no base64 encoding or payload size limits.

package/package.json

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