@agentrhq/webcmd 0.1.2 → 0.2.0

package/clis/zhihu/search.js

@@ -1,206 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
-import { stripHtml } from './text.js';
-
-function itemKey(item) {
-    const obj = item.object || {};
-    if (obj.id != null) return `${obj.type || ''}:${obj.id}`;
-    return null;
-}
-
-function itemUrl(obj) {
-    const id = obj.id == null ? '' : String(obj.id);
-    if (obj.type === 'answer') {
-        const questionId = obj.question?.id == null ? '' : String(obj.question.id);
-        return questionId && id ? `https://www.zhihu.com/question/${questionId}/answer/${id}` : '';
-    }
-    if (obj.type === 'article') {
-        return id ? `https://zhuanlan.zhihu.com/p/${id}` : '';
-    }
-    if (obj.type === 'question') {
-        return id ? `https://www.zhihu.com/question/${id}` : '';
-    }
-    return '';
-}
-
-function normalizeSearchUrl(url) {
-    if (typeof url !== 'string' || !url) return '';
-    try {
-        const parsed = new URL(url);
-        if (parsed.hostname === 'api.zhihu.com' && parsed.pathname === '/search_v3') {
-            return `https://www.zhihu.com/api/v4/search_v3${parsed.search}`;
-        }
-        if (parsed.hostname === 'www.zhihu.com' && parsed.pathname === '/api/v4/search_v3') {
-            return parsed.toString();
-        }
-    } catch {
-        return '';
-    }
-    return '';
-}
-
-const MAX_LIMIT = 1000;
-const PAGE_SIZE = 20;
-const TYPES = ['all', 'answer', 'article', 'question'];
-
-function parseLimit(value) {
-    const limit = Number(value ?? 10);
-    if (!Number.isInteger(limit) || limit <= 0 || limit > MAX_LIMIT) {
-        throw new ArgumentError(`zhihu search --limit must be a positive integer no greater than ${MAX_LIMIT}`, 'Use a normal-sized limit to avoid slow requests or Zhihu risk controls');
-    }
-    return limit;
-}
-
-function requireQuery(value) {
-    const query = String(value || '').trim();
-    if (!query) {
-        throw new ArgumentError('zhihu search query must not be empty', 'Example: webcmd zhihu search codex');
-    }
-    return query;
-}
-
-function requireType(value) {
-    const type = String(value || 'all');
-    if (!TYPES.includes(type)) {
-        throw new ArgumentError(`zhihu search --type must be one of: ${TYPES.join(', ')}`, 'Example: webcmd zhihu search codex --type answer');
-    }
-    return type;
-}
-
-function unwrapEvaluateResult(payload) {
-    if (payload && typeof payload === 'object' && 'data' in payload && 'session' in payload) return payload.data;
-    return payload;
-}
-
-function requireSearchPayload(data, url) {
-    const payload = unwrapEvaluateResult(data);
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-        throw new CommandExecutionError('Zhihu search returned malformed payload');
-    }
-    if (payload.__httpError) {
-        const status = payload.__httpError;
-        if (status === 401 || status === 403) {
-            throw new AuthRequiredError('www.zhihu.com', 'Failed to fetch search results from Zhihu');
-        }
-        throw new CommandExecutionError(`Zhihu search request failed${status ? ` (HTTP ${status})` : ''}`, 'Try again later or rerun with -v for more detail');
-    }
-    if (payload.__fetchError) {
-        throw new CommandExecutionError('Zhihu search request failed', String(payload.__fetchError));
-    }
-    if (!Array.isArray(payload.data)) {
-        throw new CommandExecutionError('Zhihu search returned malformed data list', `URL: ${url}`);
-    }
-    if (!payload.paging || typeof payload.paging !== 'object') {
-        throw new CommandExecutionError('Zhihu search returned malformed paging data', `URL: ${url}`);
-    }
-    return payload;
-}
-
-function normalizeResultItem(item) {
-    if (!item || typeof item !== 'object' || item.type !== 'search_result' || !item.object || typeof item.object !== 'object') {
-        return null;
-    }
-    const obj = item.object;
-    if (obj.type !== 'answer' && obj.type !== 'article' && obj.type !== 'question') return null;
-    const key = itemKey(item);
-    const url = itemUrl(obj);
-    const question = obj.question || {};
-    const title = stripHtml(obj.title || question.name || question.title || '');
-    if (!key || !url || !title) {
-        throw new CommandExecutionError('Zhihu search returned malformed result row identity');
-    }
-    return {
-        item,
-        key,
-        row: {
-            title,
-            type: obj.type,
-            author: obj.author?.name || '',
-            votes: obj.voteup_count || 0,
-            url,
-        },
-    };
-}
-
-cli({
-    site: 'zhihu',
-    name: 'search',
-    access: 'read',
-    description: '知乎搜索',
-    domain: 'www.zhihu.com',
-    strategy: Strategy.COOKIE,
-    args: [
-        { name: 'query', required: true, positional: true, help: 'Search query' },
-        { name: 'limit', type: 'int', default: 10, help: 'Number of results (max 1000; use normal-sized requests)' },
-        { name: 'type', default: 'all', choices: TYPES, help: 'Result type: all, answer, article, or question' },
-    ],
-    columns: ['rank', 'title', 'type', 'author', 'votes', 'url'],
-    func: async (page, kwargs) => {
-        const query = requireQuery(kwargs.query);
-        const resultLimit = parseLimit(kwargs.limit);
-        const type = requireType(kwargs.type);
-        await page.goto('https://www.zhihu.com');
-        let url = 'https://www.zhihu.com/api/v4/search_v3'
-            + `?q=${encodeURIComponent(query)}&t=general&offset=0&limit=${PAGE_SIZE}`;
-        const results = [];
-        const seen = new Set();
-        const visited = new Set();
-        while (url && results.length < resultLimit && !visited.has(url)) {
-            visited.add(url);
-            const data = requireSearchPayload(await page.evaluate(`
-      (async () => {
-        try {
-          const r = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
-          if (!r.ok) return { __httpError: r.status };
-          return await r.json();
-        } catch (err) {
-          return { __fetchError: err?.message || String(err) };
-        }
-      })()
-    `), url);
-            for (const item of data.data) {
-                const rawType = item?.object?.type;
-                if (type !== 'all' && rawType && rawType !== type) continue;
-                const normalized = normalizeResultItem(item);
-                if (!normalized) continue;
-                if (type !== 'all' && normalized.row.type !== type) continue;
-                if (seen.has(normalized.key)) continue;
-                seen.add(normalized.key);
-                results.push(normalized.row);
-                if (results.length >= resultLimit) break;
-            }
-            if (results.length >= resultLimit) break;
-            if (data.paging?.is_end) break;
-            const next = normalizeSearchUrl(data.paging?.next);
-            if (!next) {
-                throw new CommandExecutionError('Zhihu search pagination returned malformed next URL');
-            }
-            if (visited.has(next)) {
-                throw new CommandExecutionError('Zhihu search pagination returned a repeated next URL');
-            }
-            url = next;
-        }
-        if (results.length === 0) {
-            throw new EmptyResultError('zhihu search', `No ${type === 'all' ? '' : `${type} `}results found for "${query}"`);
-        }
-        return results.map((row, i) => {
-            return {
-                rank: i + 1,
-                ...row,
-            };
-        });
-    },
-});
-
-export const __test__ = {
-    stripHtml,
-    itemKey,
-    itemUrl,
-    normalizeSearchUrl,
-    parseLimit,
-    requireQuery,
-    requireType,
-    unwrapEvaluateResult,
-    requireSearchPayload,
-    normalizeResultItem,
-};

package/clis/zhihu/search.test.js

@@ -1,198 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@agentrhq/webcmd/registry';
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
-import './search.js';
-
-const {
-    normalizeSearchUrl,
-    requireSearchPayload,
-    normalizeResultItem,
-} = await import('./search.js').then((m) => m.__test__);
-
-describe('zhihu search', () => {
-    it('returns search_result entries from the Zhihu search API', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        expect(cmd?.func).toBeTypeOf('function');
-        const goto = vi.fn().mockResolvedValue(undefined);
-        const evaluate = vi.fn().mockImplementation(async (js) => {
-            expect(js).toContain('/api/v4/search_v3');
-            expect(js).toContain('limit=20');
-            expect(js).toContain("credentials: 'include'");
-            return {
-                data: [
-                    {
-                        type: 'hot_timing',
-                        object: {
-                            type: 'hot_timing',
-                            content_items: [
-                                { object: { id: 'discussion-1', type: 'article', title: 'discussion' } },
-                            ],
-                        },
-                    },
-                    {
-                        type: 'search_result',
-                        object: {
-                            id: 'a1',
-                            type: 'answer',
-                            author: { name: 'alice' },
-                            voteup_count: 12,
-                            question: { id: 'q1', name: '<em>Codex</em> &#34;question&#34;' },
-                        },
-                    },
-                    {
-                        type: 'search_result',
-                        object: {
-                            id: 'p1',
-                            type: 'article',
-                            title: '<em>Codex</em> article',
-                            author: { name: 'bob' },
-                            voteup_count: 7,
-                        },
-                    },
-                ],
-                paging: { is_end: true },
-            };
-        });
-        const page = { goto, evaluate };
-        await expect(cmd.func(page, { query: 'codex', limit: 2 })).resolves.toEqual([
-            {
-                rank: 1,
-                title: 'Codex "question"',
-                type: 'answer',
-                author: 'alice',
-                votes: 12,
-                url: 'https://www.zhihu.com/question/q1/answer/a1',
-            },
-            {
-                rank: 2,
-                title: 'Codex article',
-                type: 'article',
-                author: 'bob',
-                votes: 7,
-                url: 'https://zhuanlan.zhihu.com/p/p1',
-            },
-        ]);
-        expect(goto).toHaveBeenCalledWith('https://www.zhihu.com');
-        expect(evaluate).toHaveBeenCalledTimes(1);
-    });
-
-    it('follows paging.next until the requested limit is reached', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce({
-                    data: [
-                        { type: 'search_result', object: { id: 'a1', type: 'answer', question: { id: 'q1', name: 'first' } } },
-                        { type: 'search_result', object: { id: 'a2', type: 'answer', question: { id: 'q2', name: 'second' } } },
-                    ],
-                    paging: {
-                        is_end: false,
-                        next: 'https://api.zhihu.com/search_v3?offset=20&q=codex',
-                    },
-                })
-                .mockResolvedValueOnce({
-                    data: [
-                        { type: 'search_result', object: { id: 'a2', type: 'answer', question: { id: 'q2', name: 'duplicate' } } },
-                        { type: 'search_result', object: { id: 'q3', type: 'question', title: 'third' } },
-                    ],
-                    paging: { is_end: true },
-                }),
-        };
-        await expect(cmd.func(page, { query: 'codex', limit: 3 })).resolves.toEqual([
-            { rank: 1, title: 'first', type: 'answer', author: '', votes: 0, url: 'https://www.zhihu.com/question/q1/answer/a1' },
-            { rank: 2, title: 'second', type: 'answer', author: '', votes: 0, url: 'https://www.zhihu.com/question/q2/answer/a2' },
-            { rank: 3, title: 'third', type: 'question', author: '', votes: 0, url: 'https://www.zhihu.com/question/q3' },
-        ]);
-        expect(page.evaluate).toHaveBeenCalledTimes(2);
-        expect(page.evaluate.mock.calls[1][0]).toContain('https://www.zhihu.com/api/v4/search_v3?offset=20&q=codex');
-    });
-
-    it('filters by result type', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({
-                data: [
-                    { type: 'search_result', object: { id: 'a1', type: 'answer' } },
-                    { type: 'search_result', object: { id: 'p1', type: 'article', title: 'article' } },
-                ],
-                paging: { is_end: true },
-            }),
-        };
-        await expect(cmd.func(page, { query: 'codex', limit: 2, type: 'article' })).resolves.toEqual([
-            { rank: 1, title: 'article', type: 'article', author: '', votes: 0, url: 'https://zhuanlan.zhihu.com/p/p1' },
-        ]);
-    });
-
-    it('maps auth-like failures to AuthRequiredError', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({ __httpError: 403 }),
-        };
-        await expect(cmd.func(page, { query: 'codex', limit: 3 })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('preserves non-auth fetch failures as typed execution errors', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({ __httpError: 500 }),
-        };
-        await expect(cmd.func(page, { query: 'codex', limit: 3 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('rejects invalid input before navigation', async () => {
-        const cmd = getRegistry().get('zhihu/search');
-        const page = { goto: vi.fn(), evaluate: vi.fn() };
-        await expect(cmd.func(page, { query: '', limit: 1 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(cmd.func(page, { query: 'codex', limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(cmd.func(page, { query: 'codex', limit: 1001 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(cmd.func(page, { query: 'codex', limit: 1, type: 'video' })).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(page.evaluate).not.toHaveBeenCalled();
-    });
-
-    it('unwraps Browser Bridge envelopes and fails typed on malformed payloads', () => {
-        const payload = { data: [], paging: { is_end: true } };
-        expect(requireSearchPayload({ session: {}, data: payload }, 'https://www.zhihu.com/api/v4/search_v3')).toBe(payload);
-        expect(() => requireSearchPayload(null, 'url')).toThrow(CommandExecutionError);
-        expect(() => requireSearchPayload({ data: null, paging: { is_end: true } }, 'url')).toThrow(CommandExecutionError);
-        expect(() => requireSearchPayload({ data: [], paging: null }, 'url')).toThrow(CommandExecutionError);
-        expect(() => requireSearchPayload({ __fetchError: 'network down' }, 'url')).toThrow(CommandExecutionError);
-    });
-
-    it('fails typed on malformed supported result rows instead of emitting blank identity rows', () => {
-        expect(() => normalizeResultItem({ type: 'search_result', object: { type: 'answer', id: 'a1', question: { name: 'missing question id' } } }))
-            .toThrow(CommandExecutionError);
-        expect(() => normalizeResultItem({ type: 'search_result', object: { type: 'article', id: 'p1' } }))
-            .toThrow(CommandExecutionError);
-        expect(normalizeResultItem({ type: 'hot_timing', object: { type: 'article', id: 'p1' } })).toBe(null);
-    });
-
-    it('rejects malformed pagination next URLs and reports valid empty result separately', async () => {
-        expect(normalizeSearchUrl('https://api.zhihu.com/search_v3?offset=20&q=codex'))
-            .toBe('https://www.zhihu.com/api/v4/search_v3?offset=20&q=codex');
-        expect(normalizeSearchUrl('https://evil.example/search_v3?offset=20')).toBe('');
-
-        const cmd = getRegistry().get('zhihu/search');
-        const malformedNextPage = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({
-                data: [],
-                paging: { is_end: false, next: 'https://evil.example/search_v3?offset=20' },
-            }),
-        };
-        await expect(cmd.func(malformedNextPage, { query: 'codex', limit: 3 }))
-            .rejects.toBeInstanceOf(CommandExecutionError);
-
-        const emptyPage = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({ data: [], paging: { is_end: true } }),
-        };
-        await expect(cmd.func(emptyPage, { query: 'codex', limit: 3 }))
-            .rejects.toBeInstanceOf(EmptyResultError);
-    });
-});

package/clis/zhihu/target.js

@@ -1,91 +0,0 @@
-import { CliError } from '@agentrhq/webcmd/errors';
-const USER_RE = /^user:([A-Za-z0-9_-]+)$/;
-const QUESTION_RE = /^question:(\d+)$/;
-const ANSWER_RE = /^answer:(\d+):(\d+)$/;
-const ARTICLE_RE = /^article:(\d+)$/;
-const USER_PATH_RE = /^\/people\/([A-Za-z0-9_-]+)\/?$/;
-const QUESTION_PATH_RE = /^\/question\/(\d+)\/?$/;
-const ANSWER_PATH_RE = /^\/question\/(\d+)\/answer\/(\d+)\/?$/;
-const ARTICLE_PATH_RE = /^\/p\/(\d+)\/?$/;
-const EMPTY_AUTHORITY_RE = /^https:\/\/(?::)?@/i;
-function isAllowedZhihuUrl(url) {
-    return url.protocol === 'https:' && url.username === '' && url.password === '' && url.port === '';
-}
-export function parseTarget(input) {
-    const value = String(input).trim();
-    if (EMPTY_AUTHORITY_RE.test(value)) {
-        throw new CliError('INVALID_INPUT', 'Zhihu write commands require a normal HTTPS Zhihu URL without malformed authority', 'Example: https://www.zhihu.com/question/123456');
-    }
-    if (value.startsWith('answer:') && !ANSWER_RE.test(value)) {
-        throw new CliError('INVALID_INPUT', 'Invalid answer target, expected answer:<questionId>:<answerId>', 'Example: webcmd zhihu like answer:123:456 --execute');
-    }
-    let match = value.match(USER_RE);
-    if (match) {
-        return { kind: 'user', slug: match[1], url: `https://www.zhihu.com/people/${match[1]}` };
-    }
-    match = value.match(QUESTION_RE);
-    if (match) {
-        return { kind: 'question', id: match[1], url: `https://www.zhihu.com/question/${match[1]}` };
-    }
-    match = value.match(ANSWER_RE);
-    if (match) {
-        return {
-            kind: 'answer',
-            questionId: match[1],
-            id: match[2],
-            url: `https://www.zhihu.com/question/${match[1]}/answer/${match[2]}`,
-        };
-    }
-    match = value.match(ARTICLE_RE);
-    if (match) {
-        return { kind: 'article', id: match[1], url: `https://zhuanlan.zhihu.com/p/${match[1]}` };
-    }
-    try {
-        const url = new URL(value);
-        if (!isAllowedZhihuUrl(url)) {
-            throw new Error('unsupported zhihu url variant');
-        }
-        if (url.hostname === 'www.zhihu.com') {
-            const userMatch = url.pathname.match(USER_PATH_RE);
-            if (userMatch) {
-                const slug = userMatch[1];
-                return { kind: 'user', slug, url: `https://www.zhihu.com/people/${slug}` };
-            }
-            const questionMatch = url.pathname.match(QUESTION_PATH_RE);
-            if (questionMatch) {
-                return { kind: 'question', id: questionMatch[1], url: `https://www.zhihu.com/question/${questionMatch[1]}` };
-            }
-            const answerMatch = url.pathname.match(ANSWER_PATH_RE);
-            if (answerMatch) {
-                return {
-                    kind: 'answer',
-                    questionId: answerMatch[1],
-                    id: answerMatch[2],
-                    url: `https://www.zhihu.com/question/${answerMatch[1]}/answer/${answerMatch[2]}`,
-                };
-            }
-        }
-        if (url.hostname === 'zhuanlan.zhihu.com') {
-            const articleMatch = url.pathname.match(ARTICLE_PATH_RE);
-            if (articleMatch) {
-                return { kind: 'article', id: articleMatch[1], url: `https://zhuanlan.zhihu.com/p/${articleMatch[1]}` };
-            }
-        }
-    }
-    catch { }
-    throw new CliError('INVALID_INPUT', 'Zhihu write commands require a Zhihu URL or typed target like question:123 or answer:123:456', 'Example: webcmd zhihu like answer:123:456 --execute');
-}
-export function assertAllowedKinds(command, target) {
-    const allowed = {
-        follow: ['user', 'question'],
-        like: ['answer', 'article'],
-        favorite: ['answer', 'article'],
-        comment: ['answer', 'article'],
-        answer: ['question'],
-    };
-    if (!allowed[command]?.includes(target.kind)) {
-        throw new CliError('UNSUPPORTED_TARGET', `zhihu ${command} does not support ${target.kind} targets`);
-    }
-    return target;
-}
-export const __test__ = { parseTarget, assertAllowedKinds };

package/clis/zhihu/target.test.js

@@ -1,77 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { CliError } from '@agentrhq/webcmd/errors';
-import { __test__ } from './target.js';
-describe('zhihu target parser', () => {
-    it('parses typed answer IDs into canonical targets', () => {
-        expect(__test__.parseTarget('answer:123:456')).toEqual({
-            kind: 'answer',
-            questionId: '123',
-            id: '456',
-            url: 'https://www.zhihu.com/question/123/answer/456',
-        });
-    });
-    it('parses question URLs into canonical targets', () => {
-        expect(__test__.parseTarget('https://www.zhihu.com/question/123456')).toEqual({
-            kind: 'question',
-            id: '123456',
-            url: 'https://www.zhihu.com/question/123456',
-        });
-    });
-    it('canonicalizes question URLs with query strings and fragments', () => {
-        expect(__test__.parseTarget('https://www.zhihu.com/question/123456/?utm_source=share#answer-1')).toEqual({
-            kind: 'question',
-            id: '123456',
-            url: 'https://www.zhihu.com/question/123456',
-        });
-    });
-    it('canonicalizes answer URLs with query strings and fragments', () => {
-        expect(__test__.parseTarget('https://www.zhihu.com/question/123456/answer/7890/?utm_psn=1#comment')).toEqual({
-            kind: 'answer',
-            questionId: '123456',
-            id: '7890',
-            url: 'https://www.zhihu.com/question/123456/answer/7890',
-        });
-    });
-    it('canonicalizes article URLs with query strings and fragments', () => {
-        expect(__test__.parseTarget('https://zhuanlan.zhihu.com/p/98765/?utm_id=1#heading')).toEqual({
-            kind: 'article',
-            id: '98765',
-            url: 'https://zhuanlan.zhihu.com/p/98765',
-        });
-    });
-    it('canonicalizes user URLs with trailing slash, query strings, and fragments', () => {
-        expect(__test__.parseTarget('https://www.zhihu.com/people/example-user/?utm_term=share#about')).toEqual({
-            kind: 'user',
-            slug: 'example-user',
-            url: 'https://www.zhihu.com/people/example-user',
-        });
-    });
-    it('rejects non-https Zhihu URLs', () => {
-        expect(() => __test__.parseTarget('http://www.zhihu.com/question/123456')).toThrowError(CliError);
-    });
-    it('rejects Zhihu URLs with embedded credentials', () => {
-        expect(() => __test__.parseTarget('https://user@www.zhihu.com/question/123456')).toThrowError(CliError);
-    });
-    it('rejects Zhihu URLs with explicit ports', () => {
-        expect(() => __test__.parseTarget('https://www.zhihu.com:8443/question/123456')).toThrowError(CliError);
-    });
-    it('rejects Zhihu URLs with empty authority usernames', () => {
-        expect(() => __test__.parseTarget('https://@www.zhihu.com/question/123456')).toThrowError(CliError);
-    });
-    it('rejects Zhihu URLs with empty authority username and password markers', () => {
-        expect(() => __test__.parseTarget('https://:@www.zhihu.com/question/123456')).toThrowError(CliError);
-    });
-    it('rejects ambiguous bare numeric IDs', () => {
-        expect(() => __test__.parseTarget('123456')).toThrowError(CliError);
-    });
-    it('rejects malformed typed IDs', () => {
-        expect(() => __test__.parseTarget('answer:123')).toThrowError(/answer:<questionId>:<answerId>/);
-    });
-    it('rejects unsupported target kinds per command', () => {
-        expect(() => __test__.assertAllowedKinds('follow', {
-            kind: 'article',
-            id: '1',
-            url: 'https://zhuanlan.zhihu.com/p/1',
-        })).toThrowError(/follow/);
-    });
-});

package/clis/zhihu/text.js

@@ -1,29 +0,0 @@
-function decodeEntity(codePoint) {
-    return Number.isInteger(codePoint) && codePoint >= 0 && codePoint <= 0x10FFFF
-        ? String.fromCodePoint(codePoint)
-        : null;
-}
-
-export function stripHtml(html, { preserveBlocks = false } = {}) {
-    if (!html) return '';
-    let text = String(html);
-    if (preserveBlocks) {
-        text = text
-            .replace(/<br\s*\/?\s*>/gi, '\n')
-            .replace(/<\/(?:p|div|h[1-6]|li|blockquote)>/gi, '\n\n');
-    }
-    return text
-        .replace(/<[^>]+>/g, '')
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&amp;/g, '&')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&#(\d+);/g, (entity, value) => decodeEntity(Number(value)) ?? entity)
-        .replace(/&#x([0-9a-f]+);/gi, (entity, value) => decodeEntity(Number.parseInt(value, 16)) ?? entity)
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-}
-
-export const __test__ = { decodeEntity };

package/clis/zhihu/text.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { stripHtml } from './text.js';
-
-describe('zhihu text helpers', () => {
-    it('strips tags and decodes named entities in flat mode', () => {
-        expect(stripHtml('<em>Codex</em>&nbsp;&amp;&nbsp;&lt;CLI&gt;')).toBe('Codex & <CLI>');
-    });
-
-    it('decodes decimal and hexadecimal numeric entities', () => {
-        expect(stripHtml('&#34;中文&#34; &#x26; &#39;test&#39;')).toBe('"中文" & \'test\'');
-    });
-
-    it('keeps invalid numeric entities unchanged', () => {
-        expect(stripHtml('bad &#9999999999; entity')).toBe('bad &#9999999999; entity');
-    });
-
-    it('keeps list excerpts flat by default', () => {
-        expect(stripHtml('<p>first</p><br><p>second</p>')).toBe('firstsecond');
-    });
-
-    it('preserves block breaks when requested', () => {
-        expect(stripHtml('<p>first</p><br><p>second</p>', { preserveBlocks: true })).toBe('first\n\nsecond');
-    });
-});

package/clis/zhihu/user-answers.js

@@ -1,41 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { CommandExecutionError } from '@agentrhq/webcmd/errors';
-import { parseZhihuUser } from './user-arg.js';
-import { fetchZhihuList, validateLimit } from './paginate.js';
-
-const INCLUDE = 'data[*].voteup_count,comment_count,created_time,question';
-
-cli({
-    site: 'zhihu',
-    name: 'user-answers',
-    access: 'read',
-    description: '知乎某用户的回答列表',
-    domain: 'www.zhihu.com',
-    strategy: Strategy.COOKIE,
-    args: [
-        { name: 'user', type: 'string', required: true, positional: true, help: 'User url_token or people URL' },
-        { name: 'limit', type: 'int', default: 20, help: 'Number of answers to return (max 1000)' },
-    ],
-    columns: ['rank', 'question', 'votes', 'comments', 'created', 'url'],
-    func: async (page, kwargs) => {
-        const slug = parseZhihuUser(kwargs.user);
-        const limit = validateLimit(kwargs.limit);
-        await page.goto('https://www.zhihu.com');
-        const first = `https://www.zhihu.com/api/v4/members/${encodeURIComponent(slug)}/answers?limit=20&offset=0&include=${encodeURIComponent(INCLUDE)}`;
-        const items = await fetchZhihuList(page, first, limit, 'user answers');
-        return items.map((a, i) => {
-            const q = a.question || {};
-            if (!a.id || !q.id || !q.title) {
-                throw new CommandExecutionError('Zhihu user answers returned malformed row identity');
-            }
-            return {
-                rank: i + 1,
-                question: String(q.title || ''),
-                votes: a.voteup_count ?? a.reaction?.statistics?.like_count ?? 0,
-                comments: a.comment_count ?? 0,
-                created: a.created_time ?? a.created ?? 0,
-                url: q.id && a.id ? `https://www.zhihu.com/question/${q.id}/answer/${a.id}` : '',
-            };
-        });
-    },
-});