@jackwener/opencli 1.1.0 → 1.2.0

package/src/clis/sinablog/shared.ts

@@ -0,0 +1,198 @@
+import type { IPage } from '../../types.js';
+
+function clampLimit(limit: number): number {
+  return Math.max(1, Math.min(limit || 20, 50));
+}
+
+export function buildSinaBlogSearchUrl(keyword: string): string {
+  return `https://search.sina.com.cn/search?q=${encodeURIComponent(keyword)}&tp=mix`;
+}
+
+export function buildSinaBlogUserUrl(uid: string): string {
+  return `https://blog.sina.com.cn/s/articlelist_${encodeURIComponent(uid)}_0_1.html`;
+}
+
+export async function loadSinaBlogArticle(page: IPage, url: string): Promise<any> {
+  await page.goto(url);
+  await page.wait(3);
+  return page.evaluate(`
+    (async () => {
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const title = normalize(document.querySelector('.articalTitle h2, .title h2, h1, h2.titName')?.textContent);
+      const titleParts = normalize(document.title).split('_').map((part) => normalize(part)).filter(Boolean);
+      const author = titleParts[1] || title.split(/[：:]/)[0] || '';
+      const timeText = normalize(document.querySelector('.time, .articalInfo .time')?.textContent).replace(/[()]/g, '');
+      const date = timeText || normalize(document.body.innerText.match(/\\b\\d{4}-\\d{2}-\\d{2}(?:\\s+\\d{2}:\\d{2}:\\d{2})?\\b/)?.[0]);
+      const category = normalize(document.querySelector('.articalTag .blog_class a, .blog_class a')?.textContent);
+      const tags = Array.from(document.querySelectorAll('.blog_tag h3, .blog_tag a, .tag a, .artical_tag a'))
+        .map((node) => normalize(node.textContent))
+        .filter(Boolean);
+      const content = normalize(document.querySelector('.articalContent, .blog_content, .content, #sina_keyword_ad_area2')?.textContent).slice(0, 500);
+      const images = Array.from(document.querySelectorAll('.articalContent img, .blog_content img, .content img'))
+        .map((img) => img.getAttribute('src') || img.getAttribute('real_src') || '')
+        .filter((src) => src && !src.includes('icon'))
+        .slice(0, 5);
+      return {
+        title,
+        author,
+        date,
+        category,
+        tags: tags.join(', '),
+        readCount: '',
+        commentCount: '',
+        content: content + (content.length >= 500 ? '...' : ''),
+        images: images.join(', '),
+        url: ${JSON.stringify(url)},
+      };
+    })()
+  `);
+}
+
+export async function loadSinaBlogHot(page: IPage, limit: number): Promise<any[]> {
+  const safeLimit = clampLimit(limit);
+  await page.goto('https://blog.sina.com.cn/');
+  await page.wait(3);
+  const data = await page.evaluate(`
+    (async () => {
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const limit = ${safeLimit};
+      const abs = (href) => {
+        if (!href) return '';
+        if (href.startsWith('//')) return 'https:' + href;
+        if (href.startsWith('http')) return href;
+        return 'https://blog.sina.com.cn' + (href.startsWith('/') ? '' : '/') + href;
+      };
+      const parseArticle = (doc, fallback) => {
+        const title = normalize(doc.querySelector('.articalTitle h2, .title h2, h1, h2.titName')?.textContent) || fallback.title;
+        const titleParts = normalize(doc.title).split('_').map((part) => normalize(part)).filter(Boolean);
+        const timeText = normalize(doc.querySelector('.time, .articalInfo .time')?.textContent).replace(/[()]/g, '');
+        const articleId = fallback.url.match(/blog_([a-zA-Z0-9]+)\\.html/)?.[1] || '';
+        return {
+          articleId,
+          title,
+          author: titleParts[1] || title.split(/[：:]/)[0] || '',
+          date: timeText || '',
+          readCount: '',
+          description: normalize(doc.querySelector('.articalContent, .blog_content, .content, #sina_keyword_ad_area2')?.textContent).slice(0, 150),
+        };
+      };
+
+      const seeds = [];
+      const seen = new Set();
+      for (const link of Array.from(document.querySelectorAll('.day-hot-rank .art-list a[href*="/s/blog_"], .hot-rank .art-list a[href*="/s/blog_"]'))) {
+        const title = normalize(link.textContent);
+        const url = abs(link.getAttribute('href') || '');
+        if (!title || !url || seen.has(url)) continue;
+        seen.add(url);
+        seeds.push({ rank: seeds.length + 1, title, url });
+        if (seeds.length >= limit) break;
+      }
+
+      const results = [];
+      for (const item of seeds) {
+        let merged = {
+          rank: item.rank,
+          articleId: item.url.match(/blog_([a-zA-Z0-9]+)\\.html/)?.[1] || '',
+          title: item.title,
+          author: '',
+          date: '',
+          readCount: '',
+          description: '',
+          url: item.url,
+        };
+        try {
+          const resp = await fetch(item.url, { credentials: 'include' });
+          if (resp.ok) {
+            const html = await resp.text();
+            const doc = new DOMParser().parseFromString(html, 'text/html');
+            merged = Object.assign(merged, parseArticle(doc, item));
+          }
+        } catch {}
+        results.push(merged);
+      }
+      return results;
+    })()
+  `);
+
+  return Array.isArray(data) ? data : [];
+}
+
+export async function loadSinaBlogSearch(page: IPage, keyword: string, limit: number): Promise<any[]> {
+  const safeLimit = clampLimit(limit);
+  await page.goto(buildSinaBlogSearchUrl(keyword));
+  await page.wait(5);
+  const data = await page.evaluate(`
+    (async () => {
+      const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      for (let i = 0; i < 20; i += 1) {
+        if (document.querySelector('.result-item')) break;
+        await sleep(500);
+      }
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const limit = ${safeLimit};
+      const items = Array.from(document.querySelectorAll('.result-item'));
+      const results = [];
+      for (const item of items) {
+        const link = item.querySelector('.result-title a[href*="blog.sina.com.cn/s/blog_"]');
+        const title = normalize(link?.textContent);
+        const url = link?.getAttribute('href') || '';
+        if (!title || !url) continue;
+        results.push({
+          rank: results.length + 1,
+          title,
+          author: normalize(item.querySelector('.result-meta .source')?.textContent),
+          date: normalize(item.querySelector('.result-meta .time')?.textContent),
+          description: normalize(item.querySelector('.result-intro')?.textContent).slice(0, 150),
+          url,
+        });
+        if (results.length >= limit) break;
+      }
+      return results;
+    })()
+  `);
+
+  return Array.isArray(data) ? data : [];
+}
+
+export async function loadSinaBlogUser(page: IPage, uid: string, limit: number): Promise<any[]> {
+  const safeLimit = clampLimit(limit);
+  await page.goto(buildSinaBlogUserUrl(uid));
+  await page.wait(3);
+  const data = await page.evaluate(`
+    (async () => {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const limit = ${safeLimit};
+      const author = normalize(document.title).split('_').map((part) => normalize(part)).filter(Boolean)[1] || '';
+      const abs = (href) => {
+        if (!href) return '';
+        if (href.startsWith('//')) return 'https:' + href;
+        if (href.startsWith('http')) return href;
+        return 'https://blog.sina.com.cn' + (href.startsWith('/') ? '' : '/') + href;
+      };
+      const results = [];
+      for (const item of Array.from(document.querySelectorAll('.articleList .articleCell'))) {
+        const link = item.querySelector('.atc_title a[href*="/s/blog_"]');
+        const title = normalize(link?.textContent);
+        const url = abs(link?.getAttribute('href') || '');
+        if (!title || !url) continue;
+        results.push({
+          rank: results.length + 1,
+          articleId: url.match(/blog_([a-zA-Z0-9]+)\\.html/)?.[1] || '',
+          title,
+          author,
+          date: normalize(item.querySelector('.atc_tm')?.textContent),
+          readCount: '',
+          description: '',
+          url,
+        });
+        if (results.length >= limit) break;
+      }
+      return results;
+    })()
+  `);
+
+  return Array.isArray(data) ? data : [];
+}

package/src/clis/sinablog/user.ts

@@ -0,0 +1,16 @@
+import { cli, Strategy } from '../../registry.js';
+import { loadSinaBlogUser } from './shared.js';
+
+cli({
+  site: 'sinablog',
+  name: 'user',
+  description: '获取新浪博客用户的文章列表',
+  domain: 'blog.sina.com.cn',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'uid', required: true, positional: true, help: '新浪博客用户ID（如 1234567890）' },
+    { name: 'limit', type: 'int', default: 20, help: '返回的文章数量' },
+  ],
+  columns: ['rank', 'title', 'author', 'date', 'readCount', 'url'],
+  func: async (page, args) => loadSinaBlogUser(page, args.uid, Number(args.limit) || 20),
+});

package/src/clis/smzdm/search.ts

@@ -14,17 +14,16 @@ cli({
   domain: 'www.smzdm.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'keyword', required: true, help: 'Search keyword' },
+    { name: 'query', required: true, positional: true, help: 'Search keyword' },
     { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
   ],
   columns: ['rank', 'title', 'price', 'mall', 'comments', 'url'],
   func: async (page, kwargs) => {
-    const q = encodeURIComponent(kwargs.keyword);
+    const q = encodeURIComponent(kwargs.query);
     const limit = kwargs.limit || 20;
 
     // Navigate directly to search results page
     await page.goto(`https://search.smzdm.com/?c=home&s=${q}&v=b`);
-    await page.wait(2);
 
     const data = await page.evaluate(`
       (() => {

package/src/clis/stackoverflow/search.yaml

@@ -7,6 +7,7 @@ browser: false
 
 args:
   query:
+    positional: true
     type: string
     required: true
     description: Search query

package/src/clis/steam/top-sellers.yaml

@@ -0,0 +1,29 @@
+site: steam
+name: top-sellers
+description: Steam top selling games
+domain: store.steampowered.com
+strategy: public
+browser: false
+
+args:
+  limit:
+    type: int
+    default: 10
+    description: Number of games
+
+pipeline:
+  - fetch:
+      url: https://store.steampowered.com/api/featuredcategories/
+
+  - select: top_sellers.items
+
+  - map:
+      rank: ${{ index + 1 }}
+      name: ${{ item.name }}
+      price: ${{ item.final_price }}
+      discount: ${{ item.discount_percent }}
+      url: https://store.steampowered.com/app/${{ item.id }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, name, price, discount, url]

package/src/clis/substack/feed.ts

@@ -0,0 +1,16 @@
+import { cli, Strategy } from '../../registry.js';
+import { buildSubstackBrowseUrl, loadSubstackFeed } from './shared.js';
+
+cli({
+  site: 'substack',
+  name: 'feed',
+  description: 'Substack 热门文章 Feed',
+  domain: 'substack.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'category', default: 'all', help: '文章分类: all, tech, business, culture, politics, science, health' },
+    { name: 'limit', type: 'int', default: 20, help: '返回的文章数量' },
+  ],
+  columns: ['rank', 'title', 'author', 'date', 'readTime', 'url'],
+  func: async (page, args) => loadSubstackFeed(page, buildSubstackBrowseUrl(args.category), Number(args.limit) || 20),
+});

package/src/clis/substack/publication.ts

@@ -0,0 +1,16 @@
+import { cli, Strategy } from '../../registry.js';
+import { loadSubstackArchive } from './shared.js';
+
+cli({
+  site: 'substack',
+  name: 'publication',
+  description: '获取特定 Substack Newsletter 的最新文章',
+  domain: 'substack.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'url', required: true, positional: true, help: 'Newsletter URL（如 https://example.substack.com）' },
+    { name: 'limit', type: 'int', default: 20, help: '返回的文章数量' },
+  ],
+  columns: ['rank', 'title', 'date', 'description', 'url'],
+  func: async (page, args) => loadSubstackArchive(page, args.url.replace(/\/$/, ''), Number(args.limit) || 20),
+});

package/src/clis/substack/search.ts

@@ -0,0 +1,91 @@
+import { cli, Strategy } from '../../registry.js';
+
+type SubstackPostResult = {
+  title: string;
+  author: string;
+  date: string;
+  description: string;
+  url: string;
+};
+
+function headers(): HeadersInit {
+  return {
+    'User-Agent': 'Mozilla/5.0',
+    Accept: 'application/json',
+  };
+}
+
+function trim(value: unknown): string {
+  return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+}
+
+function publicationBaseUrl(publication: any): string {
+  if (publication?.custom_domain) return `https://${publication.custom_domain}`;
+  if (publication?.subdomain) return `https://${publication.subdomain}.substack.com`;
+  return '';
+}
+
+async function searchPosts(keyword: string, limit: number): Promise<SubstackPostResult[]> {
+  const url = new URL('https://substack.com/api/v1/post/search');
+  url.searchParams.set('query', keyword);
+  url.searchParams.set('page', '0');
+  url.searchParams.set('includePlatformResults', 'true');
+
+  const resp = await fetch(url, { headers: headers() });
+  if (!resp.ok) throw new Error(`Substack post search failed: HTTP ${resp.status}`);
+
+  const data = await resp.json() as { results?: any[] };
+  const results = Array.isArray(data?.results) ? data.results : [];
+  return results.slice(0, limit).map((item, index) => ({
+    rank: index + 1,
+    title: trim(item?.title),
+    author: trim(item?.publishedBylines?.[0]?.name),
+    date: trim(item?.post_date).split('T')[0] || trim(item?.post_date),
+    description: trim(item?.description || item?.subtitle || item?.truncated_body_text).slice(0, 150),
+    url: trim(item?.canonical_url),
+  }));
+}
+
+async function searchPublications(keyword: string, limit: number): Promise<SubstackPostResult[]> {
+  const url = new URL('https://substack.com/api/v1/profile/search');
+  url.searchParams.set('query', keyword);
+  url.searchParams.set('page', '0');
+
+  const resp = await fetch(url, { headers: headers() });
+  if (!resp.ok) throw new Error(`Substack publication search failed: HTTP ${resp.status}`);
+
+  const data = await resp.json() as { results?: any[] };
+  const results = Array.isArray(data?.results) ? data.results : [];
+  return results.slice(0, limit).map((item, index) => {
+    const publication = item?.primaryPublication || item?.publicationUsers?.[0]?.publication || {};
+    return {
+      rank: index + 1,
+      title: trim(publication?.name || item?.name),
+      author: trim(item?.name),
+      date: '',
+      description: trim(publication?.hero_text || item?.bio).slice(0, 150),
+      url: publicationBaseUrl(publication),
+    };
+  });
+}
+
+cli({
+  site: 'substack',
+  name: 'search',
+  description: '搜索 Substack 文章和 Newsletter',
+  domain: 'substack.com',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'keyword', required: true, positional: true, help: '搜索关键词' },
+    { name: 'type', default: 'posts', choices: ['posts', 'publications'], help: '搜索类型（posts=文章, publications=Newsletter）' },
+    { name: 'limit', type: 'int', default: 20, help: '返回结果数量' },
+  ],
+  columns: ['rank', 'title', 'author', 'date', 'description', 'url'],
+  func: async (_page, args) => {
+    const limit = Math.max(1, Math.min(Number(args.limit) || 20, 50));
+    return args.type === 'publications'
+      ? searchPublications(args.keyword, limit)
+      : searchPosts(args.keyword, limit);
+  },
+});

package/src/clis/substack/shared.ts

@@ -0,0 +1,132 @@
+import type { IPage } from '../../types.js';
+
+export function buildSubstackBrowseUrl(category?: string): string {
+  if (!category || category === 'all') return 'https://substack.com/';
+  const slug = category === 'tech' ? 'technology' : category;
+  return `https://substack.com/browse/${slug}`;
+}
+
+export async function loadSubstackFeed(page: IPage, url: string, limit: number): Promise<any[]> {
+  if (!page) throw new Error('Requires browser session');
+  await page.goto(url);
+  await page.wait(5);
+  const data = await page.evaluate(`
+    (async () => {
+      await new Promise((resolve) => setTimeout(resolve, 3000));
+      const limit = ${Math.max(1, Math.min(limit, 50))};
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const posts = [];
+      const seen = new Set();
+
+      const allLinks = Array.from(document.querySelectorAll('a')).filter((link) => {
+        const href = link.getAttribute('href') || '';
+        return href.includes('/home/post/') || href.includes('/p/');
+      });
+
+      for (const linkEl of allLinks) {
+        let postUrl = linkEl.getAttribute('href') || '';
+        if (!postUrl) continue;
+        if (!postUrl.startsWith('http')) postUrl = 'https://substack.com' + postUrl;
+        if (seen.has(postUrl)) continue;
+
+        const lines = (linkEl.innerText || '')
+          .split('\\n')
+          .map((line) => normalize(line))
+          .filter(Boolean);
+
+        const readMeta = lines.find((line) => /\\b(read|watch|listen)\\b/i.test(line)) || '';
+        if (!readMeta) continue;
+
+        const date = lines.find((line) => /^[A-Z]{3}\\s+\\d{1,2}$/i.test(line)) || '';
+        const contentLines = lines.filter((line) =>
+          line &&
+          line !== date &&
+          line !== readMeta &&
+          line.toLowerCase() !== 'save' &&
+          line.toLowerCase() !== 'more' &&
+          !/^(sign in|create account|get app)$/i.test(line),
+        );
+
+        const metaParts = readMeta.split('∙').map((part) => normalize(part));
+        const author = metaParts[0] || '';
+        const readTime = metaParts.slice(1).join(' ∙ ') || readMeta;
+        const title = contentLines.length >= 2 ? contentLines[1] : (contentLines[0] || '');
+        const description = contentLines.length >= 3 ? contentLines.slice(2).join(' ') : '';
+        if (!title) continue;
+
+        seen.add(postUrl);
+        posts.push({
+          rank: posts.length + 1,
+          title,
+          author,
+          date,
+          readTime,
+          description: description.slice(0, 150),
+          url: postUrl,
+        });
+
+        if (posts.length >= limit) break;
+      }
+
+      return posts;
+    })()
+  `);
+
+  return Array.isArray(data) ? data : [];
+}
+
+export async function loadSubstackArchive(page: IPage, baseUrl: string, limit: number): Promise<any[]> {
+  if (!page) throw new Error('Requires browser session');
+  await page.goto(`${baseUrl}/archive`);
+  await page.wait(5);
+  const data = await page.evaluate(`
+    (async () => {
+      await new Promise((resolve) => setTimeout(resolve, 3000));
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const limit = ${Math.max(1, Math.min(limit, 50))};
+      const grouped = new Map();
+
+      for (const link of Array.from(document.querySelectorAll('a[href*="/p/"]'))) {
+        const rawHref = link.getAttribute('href') || '';
+        if (!rawHref || rawHref === '/p/upgrade') continue;
+
+        const url = rawHref.startsWith('http') ? rawHref : ${JSON.stringify(baseUrl)} + rawHref;
+        const text = normalize(link.textContent);
+        if (!text) continue;
+        if (/^(subscribe|paid|home|about|latest|top|discussions)$/i.test(text)) continue;
+        if (/^[\\d,]+$/.test(text)) continue;
+
+        const entry = grouped.get(url) || { texts: new Set(), date: '' };
+        entry.texts.add(text);
+
+        const container = link.closest('article, section, div') || link.parentElement || link;
+        const containerText = normalize(container.textContent);
+        if (!entry.date) {
+          entry.date = containerText.match(/\\b(?:[A-Z]{3}\\s+\\d{1,2}|[A-Z][a-z]{2}\\s+\\d{1,2})\\b/)?.[0] || '';
+        }
+
+        grouped.set(url, entry);
+      }
+
+      const posts = [];
+      for (const [url, entry] of Array.from(grouped.entries())) {
+        const texts = Array.from(entry.texts).map((text) => normalize(text)).filter((text) => text.length > 3).sort((a, b) => a.length - b.length);
+        const title = texts[0] || '';
+        const description = texts.find((text) => text !== title) || '';
+        if (!title) continue;
+        posts.push({
+          rank: posts.length + 1,
+          title,
+          date: entry.date,
+          description: description.slice(0, 150),
+          url,
+        });
+        if (posts.length >= limit) break;
+      }
+
+      return posts;
+    })()
+  `);
+
+  return Array.isArray(data) ? data : [];
+}

package/src/clis/tiktok/comment.yaml

@@ -0,0 +1,66 @@
+site: tiktok
+name: comment
+description: Comment on a TikTok video
+domain: www.tiktok.com
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+  text:
+    positional: true
+    type: str
+    required: true
+    description: Comment text
+
+pipeline:
+  - navigate:
+      url: ${{ args.url }}
+      settleMs: 6000
+
+  - evaluate: |
+      (async () => {
+        const url = ${{ args.url | json }};
+        const commentText = ${{ args.text | json }};
+        const wait = (ms) => new Promise(r => setTimeout(r, ms));
+
+        // Click comment icon to expand comment section
+        const commentIcon = document.querySelector('[data-e2e="comment-icon"]');
+        if (commentIcon) {
+          const cBtn = commentIcon.closest('button') || commentIcon.closest('[role="button"]') || commentIcon;
+          cBtn.click();
+          await wait(3000);
+        }
+
+        // Count existing comments for verification
+        const beforeCount = document.querySelectorAll('[data-e2e="comment-level-1"]').length;
+
+        // Find comment input
+        const input = document.querySelector('[data-e2e="comment-input"] [contenteditable="true"]') ||
+                      document.querySelector('[contenteditable="true"]');
+        if (!input) throw new Error('Comment input not found - make sure you are logged in');
+
+        input.focus();
+        document.execCommand('insertText', false, commentText);
+        await wait(1000);
+
+        // Click post button
+        const btns = Array.from(document.querySelectorAll('[data-e2e="comment-post"], button'));
+        const postBtn = btns.find(function(b) {
+          var t = b.textContent.trim();
+          return t === 'Post' || t === '发布' || t === '发送';
+        });
+        if (!postBtn) throw new Error('Post button not found');
+        postBtn.click();
+        await wait(3000);
+
+        // Verify comment was posted by checking if comment count increased
+        const afterCount = document.querySelectorAll('[data-e2e="comment-level-1"]').length;
+        const posted = afterCount > beforeCount;
+
+        return [{ status: posted ? 'Commented' : 'Comment may have failed', url: url, text: commentText }];
+      })()
+
+columns: [status, url, text]

package/src/clis/tiktok/explore.yaml

@@ -0,0 +1,39 @@
+site: tiktok
+name: explore
+description: Get trending TikTok videos from explore page
+domain: www.tiktok.com
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of videos
+
+pipeline:
+  - navigate:
+      url: https://www.tiktok.com/explore
+      settleMs: 5000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        const links = Array.from(document.querySelectorAll('a[href*="/video/"]'));
+        const seen = new Set();
+        const results = [];
+        for (const a of links) {
+          const href = a.href;
+          if (seen.has(href)) continue;
+          seen.add(href);
+          const match = href.match(/@([^/]+)\/video\/(\d+)/);
+          results.push({
+            rank: results.length + 1,
+            author: match ? match[1] : '',
+            views: a.textContent.trim() || '-',
+            url: href,
+          });
+          if (results.length >= limit) break;
+        }
+        return results;
+      })()
+
+columns: [rank, author, views, url]

package/src/clis/tiktok/follow.yaml

@@ -0,0 +1,39 @@
+site: tiktok
+name: follow
+description: Follow a TikTok user
+domain: www.tiktok.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: TikTok username (without @)
+
+pipeline:
+  - navigate:
+      url: https://www.tiktok.com/@${{ args.username }}
+      settleMs: 6000
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const buttons = Array.from(document.querySelectorAll('button, [role="button"]'));
+        const followBtn = buttons.find(function(b) {
+          var text = b.textContent.trim();
+          return text === 'Follow' || text === '关注';
+        });
+        if (!followBtn) {
+          var isFollowing = buttons.some(function(b) {
+            var t = b.textContent.trim();
+            return t === 'Following' || t === '已关注' || t === 'Friends' || t === '互关';
+          });
+          if (isFollowing) return [{ status: 'Already following', username: username }];
+          return [{ status: 'Follow button not found', username: username }];
+        }
+        followBtn.click();
+        await new Promise(r => setTimeout(r, 2000));
+        return [{ status: 'Followed', username: username }];
+      })()
+
+columns: [status, username]