@jackwener/opencli 1.7.10 → 1.7.12

package/clis/stackoverflow/stackoverflow.test.js

@@ -0,0 +1,346 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './hot.js';
+import './search.js';
+import './unanswered.js';
+import './bounties.js';
+import './read.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('stackoverflow listing adapters surface question_id/tags/views/owner', () => {
+    it('stackoverflow/hot has the agent-native column shape', () => {
+        const cmd = getRegistry().get('stackoverflow/hot');
+        expect(cmd?.columns).toEqual([
+            'rank', 'id', 'title', 'score', 'answers', 'views',
+            'is_answered', 'tags', 'author', 'creation_date', 'url',
+        ]);
+        const mapStep = cmd?.pipeline?.find((step) => step.map);
+        expect(mapStep?.map).toMatchObject({
+            id: '${{ item.question_id }}',
+            views: '${{ item.view_count }}',
+            is_answered: '${{ item.is_answered }}',
+            author: '${{ item.owner.display_name }}',
+            creation_date: '${{ item.creation_date }}',
+        });
+    });
+
+    it('stackoverflow/search has the agent-native column shape', () => {
+        const cmd = getRegistry().get('stackoverflow/search');
+        expect(cmd?.columns).toEqual([
+            'rank', 'id', 'title', 'score', 'answers', 'views',
+            'is_answered', 'tags', 'author', 'creation_date', 'url',
+        ]);
+        const mapStep = cmd?.pipeline?.find((step) => step.map);
+        expect(mapStep?.map).toMatchObject({
+            id: '${{ item.question_id }}',
+            views: '${{ item.view_count }}',
+        });
+    });
+
+    it('stackoverflow/unanswered drops is_answered (always false) but keeps the rest', () => {
+        const cmd = getRegistry().get('stackoverflow/unanswered');
+        expect(cmd?.columns).toEqual([
+            'rank', 'id', 'title', 'score', 'answers', 'views',
+            'tags', 'author', 'creation_date', 'url',
+        ]);
+        expect(cmd?.columns).not.toContain('is_answered');
+    });
+
+    it('stackoverflow/bounties keeps the bounty column at the front', () => {
+        const cmd = getRegistry().get('stackoverflow/bounties');
+        expect(cmd?.columns).toEqual([
+            'rank', 'id', 'bounty', 'title', 'score', 'answers', 'views',
+            'is_answered', 'tags', 'author', 'creation_date', 'url',
+        ]);
+        const mapStep = cmd?.pipeline?.find((step) => step.map);
+        expect(mapStep?.map).toMatchObject({
+            id: '${{ item.question_id }}',
+            bounty: '${{ item.bounty_amount }}',
+        });
+    });
+});
+
+describe('stackoverflow/read adapter', () => {
+    const cmd = getRegistry().get('stackoverflow/read');
+
+    it('registers the question/answer/comment row shape', () => {
+        expect(cmd?.columns).toEqual(['type', 'author', 'score', 'accepted', 'text']);
+    });
+
+    it('takes a positional id plus tunable answers-limit/comments-limit/max-length', () => {
+        const argNames = (cmd?.args || []).map((a) => a.name);
+        expect(argNames).toEqual(['id', 'answers-limit', 'comments-limit', 'max-length']);
+        const idArg = cmd?.args?.find((a) => a.name === 'id');
+        expect(idArg?.required).toBe(true);
+        expect(idArg?.positional).toBe(true);
+    });
+
+    it('uses the public Stack Exchange API (no browser, public strategy)', () => {
+        expect(cmd?.browser).toBe(false);
+        expect(cmd?.strategy).toBe('public');
+    });
+
+    it('fails fast with ArgumentError for non-numeric id before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: 'not-a-number', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 4000 }))
+            .rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('fails fast with ArgumentError for max-length below 100 before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: '12345', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 50 }))
+            .rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('fails fast with EmptyResultError when the question lookup returns empty items', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(
+            new Response(JSON.stringify({ items: [] }), { status: 200 }),
+        ));
+
+        await expect(cmd.func({ id: '99999999', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 4000 }))
+            .rejects.toThrow(EmptyResultError);
+    });
+
+    it('surfaces Stack Exchange API throttle / quota errors as CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(
+            new Response(JSON.stringify({ error_id: 502, error_name: 'throttle_violation', error_message: 'too fast' }), { status: 200 }),
+        ));
+
+        await expect(cmd.func({ id: '12345', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 4000 }))
+            .rejects.toThrow(CommandExecutionError);
+    });
+
+    it('wraps fetch network failures in CommandExecutionError (not raw TypeError)', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new TypeError('fetch failed')));
+
+        await expect(cmd.func({ id: '12345', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 4000 }))
+            .rejects.toThrow(CommandExecutionError);
+    });
+
+    it('wraps malformed JSON responses in CommandExecutionError (not raw SyntaxError)', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(
+            new Response('<!DOCTYPE html><html>maintenance</html>', { status: 200 }),
+        ));
+
+        await expect(cmd.func({ id: '12345', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 4000 }))
+            .rejects.toThrow(CommandExecutionError);
+    });
+
+    it('coerces and validates string-form numeric args (e.g. "50" not Number(50))', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        // String "50" should still be rejected because it's < 100
+        await expect(cmd.func({ id: '12345', 'answers-limit': 10, 'comments-limit': 5, 'max-length': '50' }))
+            .rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+
+        // String "abc" should also be rejected
+        await expect(cmd.func({ id: '12345', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 'abc' }))
+            .rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('rejects answer/comment limits above Stack Exchange pagesize max before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: '12345', 'answers-limit': '101', 'comments-limit': 5, 'max-length': 4000 }))
+            .rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: '12345', 'answers-limit': 10, 'comments-limit': '101', 'max-length': 4000 }))
+            .rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('builds POST + Q-COMMENT + ANSWER + A-COMMENT rows, accepted answer first', async () => {
+        const question = {
+            items: [{
+                question_id: 1,
+                title: 'Why?',
+                body: '<p>Question body</p>',
+                score: 10,
+                link: 'https://example.com/q/1',
+                owner: { display_name: 'asker' },
+            }],
+        };
+        const qComments = {
+            items: [
+                { score: 2, owner: { display_name: 'qc1' }, body: '<p>q comment one</p>' },
+                { score: 1, owner: { display_name: 'qc2' }, body: '<p>q comment two</p>' },
+            ],
+        };
+        const answers = {
+            items: [
+                { answer_id: 100, score: 5, is_accepted: false, owner: { display_name: 'low' }, body: '<p>low score answer</p>' },
+                { answer_id: 200, score: 50, is_accepted: true, owner: { display_name: 'winner' }, body: '<p>accepted answer</p>' },
+            ],
+        };
+        const answerComments = {
+            items: [
+                { post_id: 200, score: 1, owner: { display_name: 'ac1' }, body: '<p>comment on accepted</p>' },
+                { post_id: 100, score: 0, owner: { display_name: 'ac2' }, body: '<p>comment on low</p>' },
+            ],
+        };
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce(new Response(JSON.stringify(question), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify(qComments), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify(answers), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify(answerComments), { status: 200 }));
+        vi.stubGlobal('fetch', fetchMock);
+
+        const rows = await cmd.func({ id: '1', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 4000 });
+
+        expect(rows.map((r) => [r.type, r.author, r.accepted])).toEqual([
+            ['POST', 'asker', ''],
+            ['Q-COMMENT', 'qc1', ''],
+            ['Q-COMMENT', 'qc2', ''],
+            ['ANSWER', 'winner', 'true'],   // accepted comes FIRST
+            ['A-COMMENT', 'ac1', ''],
+            ['ANSWER', 'low', ''],
+            ['A-COMMENT', 'ac2', ''],
+        ]);
+
+        // Verify the answer-comments fetch batched both answer ids
+        const ansCommentsCall = fetchMock.mock.calls[3][0];
+        expect(ansCommentsCall).toContain('/answers/200;100/comments');
+        expect(fetchMock.mock.calls[1][0]).toContain('pagesize=5');
+        expect(fetchMock.mock.calls[2][0]).toContain('pagesize=10');
+        expect(fetchMock.mock.calls[3][0]).toContain('pagesize=10');
+    });
+
+    it('fetches accepted answer separately when it is missing from the votes page', async () => {
+        const question = {
+            items: [{
+                question_id: 1,
+                accepted_answer_id: 999,
+                title: 'Why?',
+                body: '<p>Question body</p>',
+                score: 10,
+                link: 'https://example.com/q/1',
+                owner: { display_name: 'asker' },
+            }],
+        };
+        const answers = {
+            items: [
+                { answer_id: 100, score: 50, is_accepted: false, owner: { display_name: 'top-voted' }, body: '<p>top voted answer</p>' },
+            ],
+        };
+        const acceptedAnswer = {
+            items: [
+                { answer_id: 999, score: 1, is_accepted: true, owner: { display_name: 'accepted' }, body: '<p>accepted answer</p>' },
+            ],
+        };
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce(new Response(JSON.stringify(question), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({ items: [] }), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify(answers), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify(acceptedAnswer), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({ items: [] }), { status: 200 }));
+        vi.stubGlobal('fetch', fetchMock);
+
+        const rows = await cmd.func({ id: '1', 'answers-limit': 2, 'comments-limit': 5, 'max-length': 4000 });
+
+        expect(rows.filter((r) => r.type === 'ANSWER').map((r) => [r.author, r.accepted])).toEqual([
+            ['accepted', 'true'],
+            ['top-voted', ''],
+        ]);
+        expect(fetchMock.mock.calls[3][0]).toContain('/answers/999?');
+        expect(fetchMock.mock.calls[4][0]).toContain('/answers/999;100/comments');
+        expect(fetchMock.mock.calls[4][0]).toContain('pagesize=10');
+    });
+
+    it('fails fast when batched answer comments would be partial', async () => {
+        const question = {
+            items: [{
+                question_id: 1,
+                title: 'Why?',
+                body: '<p>Question body</p>',
+                score: 10,
+                link: 'https://example.com/q/1',
+                owner: { display_name: 'asker' },
+            }],
+        };
+        const answers = {
+            items: [
+                { answer_id: 100, score: 50, is_accepted: false, owner: { display_name: 'a1' }, body: '<p>one</p>' },
+                { answer_id: 200, score: 40, is_accepted: false, owner: { display_name: 'a2' }, body: '<p>two</p>' },
+            ],
+        };
+        const answerComments = {
+            has_more: true,
+            items: [
+                { post_id: 100, score: 1, owner: { display_name: 'c1' }, body: '<p>comment on first</p>' },
+            ],
+        };
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce(new Response(JSON.stringify(question), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({ items: [] }), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify(answers), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify(answerComments), { status: 200 }));
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: '1', 'answers-limit': 2, 'comments-limit': 1, 'max-length': 4000 }))
+            .rejects.toThrow(CommandExecutionError);
+    });
+
+    it('decodes HTML entities in body and display_name (named, decimal, hex)', async () => {
+        const question = {
+            items: [{
+                question_id: 1,
+                title: 't',
+                body: '<p>price &lt; &amp; &hellip; &#246; &#x27;ok&#x27;</p>',
+                score: 0,
+                link: '',
+                owner: { display_name: 'Jonas K&#246;lker' },
+            }],
+        };
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce(new Response(JSON.stringify(question), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({ items: [] }), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({ items: [] }), { status: 200 }));
+        vi.stubGlobal('fetch', fetchMock);
+
+        const rows = await cmd.func({ id: '1', 'answers-limit': 10, 'comments-limit': 5, 'max-length': 4000 });
+
+        expect(rows[0].author).toBe('Jonas Kölker');
+        expect(rows[0].text).toContain('price < & … ö \'ok\'');
+    });
+
+    it('respects answers-limit when there are more answers than the cap', async () => {
+        const question = {
+            items: [{
+                question_id: 1, title: 't', body: '', score: 0, link: '',
+                owner: { display_name: 'a' },
+            }],
+        };
+        const answers = {
+            items: [
+                { answer_id: 100, score: 5, is_accepted: false, owner: { display_name: 'a1' }, body: '' },
+                { answer_id: 200, score: 4, is_accepted: false, owner: { display_name: 'a2' }, body: '' },
+                { answer_id: 300, score: 3, is_accepted: false, owner: { display_name: 'a3' }, body: '' },
+            ],
+        };
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce(new Response(JSON.stringify(question), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({ items: [] }), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify(answers), { status: 200 }))
+            .mockResolvedValueOnce(new Response(JSON.stringify({ items: [] }), { status: 200 }));
+        vi.stubGlobal('fetch', fetchMock);
+
+        const rows = await cmd.func({ id: '1', 'answers-limit': 2, 'comments-limit': 5, 'max-length': 4000 });
+
+        const answerRows = rows.filter((r) => r.type === 'ANSWER');
+        expect(answerRows.map((r) => r.author)).toEqual(['a1', 'a2']);
+    });
+});

package/clis/stackoverflow/unanswered.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'stackoverflow',
     name: 'unanswered',
+    access: 'read',
     description: 'Top voted unanswered questions on Stack Overflow',
     domain: 'stackoverflow.com',
     strategy: Strategy.PUBLIC,
@@ -9,16 +10,22 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 10, help: 'Max number of results' },
     ],
-    columns: ['title', 'score', 'answers', 'url'],
+    columns: ['rank', 'id', 'title', 'score', 'answers', 'views', 'tags', 'author', 'creation_date', 'url'],
     pipeline: [
         { fetch: {
-                url: 'https://api.stackexchange.com/2.3/questions/unanswered?order=desc&sort=votes&site=stackoverflow',
+                url: 'https://api.stackexchange.com/2.3/questions/unanswered?order=desc&sort=votes&site=stackoverflow&pagesize=${{ args.limit }}',
             } },
         { select: 'items' },
         { map: {
+                rank: '${{ index + 1 }}',
+                id: '${{ item.question_id }}',
                 title: '${{ item.title }}',
                 score: '${{ item.score }}',
                 answers: '${{ item.answer_count }}',
+                views: '${{ item.view_count }}',
+                tags: `\${{ item.tags | join(', ') }}`,
+                author: '${{ item.owner.display_name }}',
+                creation_date: '${{ item.creation_date }}',
                 url: '${{ item.link }}',
             } },
         { limit: '${{ args.limit }}' },

package/clis/steam/top-sellers.js

@@ -2,6 +2,7 @@ import { cli, Strategy } from '@jackwener/opencli/registry';
 cli({
     site: 'steam',
     name: 'top-sellers',
+    access: 'read',
     description: 'Steam top selling games',
     domain: 'store.steampowered.com',
     strategy: Strategy.PUBLIC,

package/clis/substack/feed.js

@@ -3,6 +3,7 @@ import { buildSubstackBrowseUrl, loadSubstackFeed } from './utils.js';
 cli({
     site: 'substack',
     name: 'feed',
+    access: 'read',
     description: 'Substack 热门文章 Feed',
     domain: 'substack.com',
     strategy: Strategy.COOKIE,

package/clis/substack/publication.js

@@ -3,6 +3,7 @@ import { loadSubstackArchive } from './utils.js';
 cli({
     site: 'substack',
     name: 'publication',
+    access: 'read',
     description: '获取特定 Substack Newsletter 的最新文章',
     domain: 'substack.com',
     strategy: Strategy.COOKIE,

package/clis/substack/search.js

@@ -59,6 +59,7 @@ async function searchPublications(keyword, limit) {
 cli({
     site: 'substack',
     name: 'search',
+    access: 'read',
     description: '搜索 Substack 文章和 Newsletter',
     domain: 'substack.com',
     strategy: Strategy.PUBLIC,

package/clis/taobao/add-cart.js

@@ -4,6 +4,7 @@ import { normalizeNumericId } from '../_shared/common.js';
 cli({
     site: 'taobao',
     name: 'add-cart',
+    access: 'write',
     description: '淘宝加入购物车',
     domain: 'item.taobao.com',
     strategy: Strategy.COOKIE,

package/clis/taobao/cart.js

@@ -4,6 +4,7 @@ import { clampInt } from '../_shared/common.js';
 cli({
     site: 'taobao',
     name: 'cart',
+    access: 'read',
     description: '查看淘宝购物车',
     domain: 'cart.taobao.com',
     strategy: Strategy.COOKIE,

package/clis/taobao/detail.js

@@ -3,6 +3,7 @@ import { normalizeNumericId } from '../_shared/common.js';
 cli({
     site: 'taobao',
     name: 'detail',
+    access: 'read',
     description: '淘宝商品详情',
     domain: 'item.taobao.com',
     strategy: Strategy.COOKIE,

package/clis/taobao/reviews.js

@@ -3,6 +3,7 @@ import { clampInt, normalizeNumericId } from '../_shared/common.js';
 cli({
     site: 'taobao',
     name: 'reviews',
+    access: 'read',
     description: '淘宝商品评价',
     domain: 'item.taobao.com',
     strategy: Strategy.COOKIE,

package/clis/taobao/search.js

@@ -4,6 +4,7 @@ import { clampInt, requireNonEmptyQuery } from '../_shared/common.js';
 cli({
     site: 'taobao',
     name: 'search',
+    access: 'read',
     description: '淘宝商品搜索',
     domain: 's.taobao.com',
     strategy: Strategy.COOKIE,

package/clis/tdx/hot-rank.js

@@ -5,6 +5,7 @@ const TDX_HOT_URL = 'https://pul.tdx.com.cn/site/app/gzhbd/tdx-topsearch/page-ma
 cli({
   site: 'tdx',
   name: 'hot-rank',
+    access: 'read',
   description: '通达信热搜榜',
   domain: 'pul.tdx.com.cn',
   strategy: Strategy.COOKIE,

package/clis/ths/hot-rank.js

@@ -5,6 +5,7 @@ const THS_HOT_URL = 'https://eq.10jqka.com.cn/webpage/ths-hot-list/index.html?sh
 cli({
   site: 'ths',
   name: 'hot-rank',
+    access: 'read',
   description: '同花顺热股榜',
   domain: 'eq.10jqka.com.cn',
   strategy: Strategy.COOKIE,

package/clis/tieba/hot.js

@@ -4,6 +4,7 @@ import { normalizeTiebaLimit } from './utils.js';
 cli({
     site: 'tieba',
     name: 'hot',
+    access: 'read',
     description: 'Tieba hot topics',
     domain: 'tieba.baidu.com',
     strategy: Strategy.PUBLIC,
@@ -12,7 +13,7 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
     ],
-    columns: ['rank', 'title', 'discussions', 'description'],
+    columns: ['rank', 'title', 'discussions', 'description', 'url'],
     func: async (page, kwargs) => {
         const limit = normalizeTiebaLimit(kwargs.limit);
         // Use the default browser settle path so we do not scrape the previous page.

package/clis/tieba/posts.js

@@ -60,6 +60,7 @@ async function fetchTiebaPagePc(page, kwargs, limit) {
 cli({
     site: 'tieba',
     name: 'posts',
+    access: 'read',
     description: 'Browse posts in a tieba forum',
     domain: 'tieba.baidu.com',
     strategy: Strategy.COOKIE,

package/clis/tieba/read.js

@@ -111,6 +111,7 @@ function buildExtractReadEvaluate() {
 cli({
     site: 'tieba',
     name: 'read',
+    access: 'read',
     description: 'Read a tieba thread',
     domain: 'tieba.baidu.com',
     strategy: Strategy.COOKIE,

package/clis/tieba/search.js

@@ -81,6 +81,7 @@ function assertSupportedPage(kwargs) {
 cli({
     site: 'tieba',
     name: 'search',
+    access: 'read',
     description: 'Search posts across tieba',
     domain: 'tieba.baidu.com',
     strategy: Strategy.COOKIE,
@@ -92,7 +93,7 @@ cli({
         { name: 'page', type: 'int', default: 1, choices: ['1'], help: 'Page number (currently only 1 is supported)' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
     ],
-    columns: ['rank', 'title', 'forum', 'author', 'time'],
+    columns: ['rank', 'id', 'title', 'forum', 'author', 'time', 'url'],
     func: async (page, kwargs) => {
         assertSupportedPage(kwargs);
         const limit = normalizeTiebaLimit(kwargs.limit);

package/clis/tiktok/comment.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'comment',
+    access: 'write',
     description: 'Comment on a TikTok video',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/explore.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'explore',
+    access: 'read',
     description: 'Get trending TikTok videos from explore page',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/follow.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'follow',
+    access: 'write',
     description: 'Follow a TikTok user',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/following.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'following',
+    access: 'read',
     description: 'List accounts you follow on TikTok',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/friends.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'friends',
+    access: 'read',
     description: 'Get TikTok friend suggestions',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/like.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'like',
+    access: 'write',
     description: 'Like a TikTok video',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/live.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'live',
+    access: 'read',
     description: 'Browse live streams on TikTok',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/notifications.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'notifications',
+    access: 'read',
     description: 'Get TikTok notifications (likes, comments, mentions, followers)',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/profile.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'profile',
+    access: 'read',
     description: 'Get TikTok user profile info',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/save.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'save',
+    access: 'write',
     description: 'Add a TikTok video to Favorites',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/search.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'search',
+    access: 'read',
     description: 'Search TikTok videos',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/unfollow.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'unfollow',
+    access: 'write',
     description: 'Unfollow a TikTok user',
     domain: 'www.tiktok.com',
     args: [

package/clis/tiktok/unlike.js

@@ -2,6 +2,7 @@ import { cli } from '@jackwener/opencli/registry';
 cli({
     site: 'tiktok',
     name: 'unlike',
+    access: 'write',
     description: 'Unlike a TikTok video',
     domain: 'www.tiktok.com',
     args: [