@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/tiktok/profile.yaml

@@ -0,0 +1,45 @@
+site: tiktok
+name: profile
+description: Get TikTok user profile info
+domain: www.tiktok.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: TikTok username (without @)
+
+pipeline:
+  - navigate:
+      url: https://www.tiktok.com/explore
+      settleMs: 5000
+
+  - evaluate: |
+      (async () => {
+        const username = ${{ args.username | json }};
+        const res = await fetch('https://www.tiktok.com/@' + encodeURIComponent(username), { credentials: 'include' });
+        if (!res.ok) throw new Error('User not found: ' + username);
+        const html = await res.text();
+        const idx = html.indexOf('__UNIVERSAL_DATA_FOR_REHYDRATION__');
+        if (idx === -1) throw new Error('Could not parse profile data');
+        const start = html.indexOf('>', idx) + 1;
+        const end = html.indexOf('</script>', start);
+        const data = JSON.parse(html.substring(start, end));
+        const ud = data['__DEFAULT_SCOPE__'] && data['__DEFAULT_SCOPE__']['webapp.user-detail'];
+        const u = ud && ud.userInfo && ud.userInfo.user;
+        const s = ud && ud.userInfo && ud.userInfo.stats;
+        if (!u) throw new Error('User not found: ' + username);
+        return [{
+          username: u.uniqueId || username,
+          name: u.nickname || '',
+          bio: (u.signature || '').replace(/\n/g, ' ').substring(0, 120),
+          followers: s && s.followerCount || 0,
+          following: s && s.followingCount || 0,
+          likes: s && s.heartCount || 0,
+          videos: s && s.videoCount || 0,
+          verified: u.verified ? 'Yes' : 'No',
+        }];
+      })()
+
+columns: [username, name, followers, following, likes, videos, verified, bio]

package/vendor/opencli/dist/clis/tiktok/save.yaml

@@ -0,0 +1,34 @@
+site: tiktok
+name: save
+description: Add a TikTok video to Favorites
+domain: www.tiktok.com
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+
+pipeline:
+  - navigate:
+      url: ${{ args.url }}
+      settleMs: 6000
+
+  - evaluate: |
+      (async () => {
+        const url = ${{ args.url | json }};
+        const btn = document.querySelector('[data-e2e="bookmark-icon"]') ||
+                    document.querySelector('[data-e2e="collect-icon"]');
+        if (!btn) throw new Error('Favorites button not found - make sure you are logged in');
+        const container = btn.closest('button') || btn.closest('[role="button"]') || btn;
+        const aria = (container.getAttribute('aria-label') || '').toLowerCase();
+        if (aria.includes('remove from favorites') || aria.includes('取消收藏')) {
+          return [{ status: 'Already in Favorites', url: url }];
+        }
+        container.click();
+        await new Promise(r => setTimeout(r, 2000));
+        return [{ status: 'Added to Favorites', url: url }];
+      })()
+
+columns: [status, url]

package/vendor/opencli/dist/clis/tiktok/search.yaml

@@ -0,0 +1,47 @@
+site: tiktok
+name: search
+description: Search TikTok videos
+domain: www.tiktok.com
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Search query
+  limit:
+    type: int
+    default: 10
+    description: Number of results
+
+pipeline:
+  - navigate:
+      url: https://www.tiktok.com/explore
+      settleMs: 5000
+
+  - evaluate: |
+      (async () => {
+        const query = ${{ args.query | json }};
+        const limit = ${{ args.limit }};
+        const res = await fetch('/api/search/general/full/?keyword=' + encodeURIComponent(query) + '&offset=0&count=' + limit + '&aid=1988', { credentials: 'include' });
+        if (!res.ok) throw new Error('Search failed: HTTP ' + res.status);
+        const data = await res.json();
+        const items = (data.data || []).filter(function(i) { return i.type === 1 && i.item; });
+        return items.slice(0, limit).map(function(i, idx) {
+          var v = i.item;
+          var a = v.author || {};
+          var s = v.stats || {};
+          return {
+            rank: idx + 1,
+            desc: (v.desc || '').replace(/\n/g, ' ').substring(0, 100),
+            author: a.uniqueId || '',
+            url: (a.uniqueId && v.id) ? 'https://www.tiktok.com/@' + a.uniqueId + '/video/' + v.id : '',
+            plays: s.playCount || 0,
+            likes: s.diggCount || 0,
+            comments: s.commentCount || 0,
+            shares: s.shareCount || 0,
+          };
+        });
+      })()
+
+columns: [rank, desc, author, url, plays, likes, comments, shares]

package/vendor/opencli/dist/clis/tiktok/unfollow.yaml

@@ -0,0 +1,44 @@
+site: tiktok
+name: unfollow
+description: Unfollow 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 followingBtn = buttons.find(function(b) {
+          var text = b.textContent.trim();
+          return text === 'Following' || text === '已关注' || text === 'Friends' || text === '互关';
+        });
+        if (!followingBtn) {
+          return [{ status: 'Not following this user', username: username }];
+        }
+        followingBtn.click();
+        await new Promise(r => setTimeout(r, 2000));
+        // Confirm unfollow if dialog appears
+        var allBtns = Array.from(document.querySelectorAll('button'));
+        var confirm = allBtns.find(function(b) {
+          var t = b.textContent.trim();
+          return t === 'Unfollow' || t === '取消关注';
+        });
+        if (confirm) {
+          confirm.click();
+          await new Promise(r => setTimeout(r, 1500));
+        }
+        return [{ status: 'Unfollowed', username: username }];
+      })()
+
+columns: [status, username]

package/vendor/opencli/dist/clis/tiktok/unlike.yaml

@@ -0,0 +1,38 @@
+site: tiktok
+name: unlike
+description: Unlike a TikTok video
+domain: www.tiktok.com
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+
+pipeline:
+  - navigate:
+      url: ${{ args.url }}
+      settleMs: 6000
+
+  - evaluate: |
+      (async () => {
+        const url = ${{ args.url | json }};
+        const btn = document.querySelector('[data-e2e="like-icon"]');
+        if (!btn) throw new Error('Like button not found - make sure you are logged in');
+        const container = btn.closest('button') || btn.closest('[role="button"]') || btn;
+        const aria = (container.getAttribute('aria-label') || '').toLowerCase();
+        const color = window.getComputedStyle(btn).color;
+        const isLiked = aria.includes('unlike') || aria.includes('取消点赞') ||
+                        (color && (color.includes('255, 65') || color.includes('fe2c55')));
+        if (!isLiked) {
+          const count = document.querySelector('[data-e2e="like-count"]');
+          return [{ status: 'Not liked', likes: count ? count.textContent.trim() : '-', url: url }];
+        }
+        container.click();
+        await new Promise(r => setTimeout(r, 2000));
+        const count = document.querySelector('[data-e2e="like-count"]');
+        return [{ status: 'Unliked', likes: count ? count.textContent.trim() : '-', url: url }];
+      })()
+
+columns: [status, likes, url]

package/vendor/opencli/dist/clis/tiktok/unsave.yaml

@@ -0,0 +1,36 @@
+site: tiktok
+name: unsave
+description: Remove a TikTok video from Favorites
+domain: www.tiktok.com
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+
+pipeline:
+  - navigate:
+      url: ${{ args.url }}
+      settleMs: 6000
+
+  - evaluate: |
+      (async () => {
+        const url = ${{ args.url | json }};
+        const btn = document.querySelector('[data-e2e="bookmark-icon"]') ||
+                    document.querySelector('[data-e2e="collect-icon"]');
+        if (!btn) throw new Error('Favorites button not found - make sure you are logged in');
+        const container = btn.closest('button') || btn.closest('[role="button"]') || btn;
+        const aria = (container.getAttribute('aria-label') || '').toLowerCase();
+        if (aria.includes('add to favorites') || aria.includes('收藏')) {
+          if (!aria.includes('remove') && !aria.includes('取消')) {
+            return [{ status: 'Not in Favorites', url: url }];
+          }
+        }
+        container.click();
+        await new Promise(r => setTimeout(r, 2000));
+        return [{ status: 'Removed from Favorites', url: url }];
+      })()
+
+columns: [status, url]

package/vendor/opencli/dist/clis/tiktok/user.yaml

@@ -0,0 +1,44 @@
+site: tiktok
+name: user
+description: Get recent videos from a TikTok user
+domain: www.tiktok.com
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: TikTok username (without @)
+  limit:
+    type: int
+    default: 10
+    description: Number of videos
+
+pipeline:
+  - navigate:
+      url: https://www.tiktok.com/@${{ args.username }}
+      settleMs: 6000
+
+  - evaluate: |
+      (() => {
+        const limit = ${{ args.limit }};
+        const username = ${{ args.username | json }};
+        const links = Array.from(document.querySelectorAll('a[href*="/video/"]'));
+        const seen = {};
+        const results = [];
+        for (const a of links) {
+          const href = a.href;
+          if (seen[href]) continue;
+          seen[href] = true;
+          results.push({
+            index: results.length + 1,
+            views: a.textContent.trim() || '-',
+            url: href,
+          });
+          if (results.length >= limit) break;
+        }
+        if (results.length === 0) throw new Error('No videos found for @' + username);
+        return results;
+      })()
+
+columns: [index, views, url]

package/vendor/opencli/dist/clis/twitter/accept.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/twitter/accept.js

@@ -0,0 +1,203 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'accept',
+    description: 'Auto-accept DM requests containing specific keywords',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    timeoutSeconds: 600, // 10 min — batch operation iterating many conversations
+    args: [
+        { name: 'query', type: 'string', required: true, positional: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
+        { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of requests to accept (default: 20)' },
+    ],
+    columns: ['index', 'status', 'user', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter accept');
+        const keywords = kwargs.query.split(',').map((k) => k.trim()).filter(Boolean);
+        const maxAccepts = kwargs.max ?? 20;
+        const results = [];
+        let acceptCount = 0;
+        // Track already-visited conversations to avoid infinite loops
+        const visited = new Set();
+        for (let round = 0; round < maxAccepts + 50; round++) {
+            if (acceptCount >= maxAccepts)
+                break;
+            // Step 1: Navigate to DM requests page
+            await page.goto('https://x.com/messages/requests');
+            await page.wait(4);
+            // Step 2: Get conversations with scroll-to-load
+            const convInfo = await page.evaluate(`(async () => {
+        try {
+          // Wait for initial items
+          let attempts = 0;
+          while (attempts < 10) {
+            const convs = document.querySelectorAll('[data-testid="conversation"]');
+            if (convs.length > 0) break;
+            await new Promise(r => setTimeout(r, 1000));
+            attempts++;
+          }
+
+          // Scroll to load more
+          const seenCount = new Set();
+          let noNewCount = 0;
+          for (let scroll = 0; scroll < 20; scroll++) {
+            const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+            const prevSize = seenCount.size;
+            convs.forEach((_, i) => seenCount.add(i));
+            if (convs.length >= ${maxAccepts + 10}) break;
+
+            // Scroll last item into view
+            if (convs.length > 0) {
+              convs[convs.length - 1].scrollIntoView({ behavior: 'instant', block: 'end' });
+            }
+            await new Promise(r => setTimeout(r, 1500));
+
+            if (seenCount.size <= prevSize) {
+              noNewCount++;
+              if (noNewCount >= 3) break;
+            } else {
+              noNewCount = 0;
+            }
+          }
+
+          const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+          if (convs.length === 0) return { ok: false, count: 0, items: [] };
+
+          const items = convs.map((conv, idx) => {
+            const text = conv.innerText || '';
+            const link = conv.querySelector('a[href]');
+            const href = link ? link.href : '';
+            const lines = text.split('\\n').filter(l => l.trim());
+            const user = lines[0] || 'Unknown';
+            return { idx, text, href, user };
+          });
+          return { ok: true, count: convs.length, items };
+        } catch(e) {
+          return { ok: false, error: String(e), count: 0, items: [] };
+        }
+      })()`);
+            if (!convInfo?.ok || convInfo.count === 0) {
+                if (results.length === 0) {
+                    results.push({ index: 1, status: 'info', user: 'System', message: 'No message requests found' });
+                }
+                break;
+            }
+            let foundInThisRound = false;
+            // Step 3: Find first unvisited conversation with keyword match in preview
+            for (const item of convInfo.items) {
+                if (acceptCount >= maxAccepts)
+                    break;
+                const convKey = item.href || `conv-${item.idx}`;
+                if (visited.has(convKey))
+                    continue;
+                visited.add(convKey);
+                // Check if preview text contains any keyword
+                const previewMatch = keywords.some((k) => item.text.includes(k));
+                if (!previewMatch)
+                    continue;
+                // Step 4: Click this conversation to open it
+                const clickResult = await page.evaluate(`(async () => {
+          try {
+            const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+            const conv = convs[${item.idx}];
+            if (!conv) return { ok: false, error: 'Conversation element not found' };
+            conv.click();
+            await new Promise(r => setTimeout(r, 2000));
+            return { ok: true };
+          } catch(e) {
+            return { ok: false, error: String(e) };
+          }
+        })()`);
+                if (!clickResult?.ok)
+                    continue;
+                // Wait for conversation to load
+                await page.wait(2);
+                // Step 5: Read full chat content and find Accept button
+                const res = await page.evaluate(`(async () => {
+          try {
+            const keywords = ${JSON.stringify(keywords)};
+
+            // Get username from conversation header
+            const heading = document.querySelector('[data-testid="conversation-header"]') ||
+                            document.querySelector('[data-testid="DM-conversation-header"]');
+            let username = 'Unknown';
+            if (heading) {
+              username = heading.innerText.trim().split('\\n')[0];
+            }
+
+            // Read full chat area text
+            const chatArea = document.querySelector('[data-testid="DmScrollerContainer"]') ||
+                             document.querySelector('[data-testid="DMConversationBody"]') ||
+                             document.querySelector('main [data-testid="cellInnerDiv"]')?.closest('section') ||
+                             document.querySelector('main');
+            const text = chatArea ? chatArea.innerText : '';
+
+            // Verify keyword match in full chat content
+            const matchedKw = keywords.filter(k => text.includes(k));
+            if (matchedKw.length === 0) {
+              return { status: 'skipped', user: username, message: 'No keyword match in full content' };
+            }
+
+            // Find the Accept button
+            const allBtns = Array.from(document.querySelectorAll('[role="button"]'));
+            const acceptBtn = allBtns.find(btn => {
+              const t = btn.innerText.trim().toLowerCase();
+              return t === 'accept' || t === '接受';
+            });
+
+            if (!acceptBtn) {
+              return { status: 'no_button', user: username, message: 'Keyword matched but no Accept button (already accepted?)' };
+            }
+
+            // Click Accept
+            acceptBtn.click();
+            await new Promise(r => setTimeout(r, 2000));
+
+            // Check for confirmation dialog
+            const btnsAfter = Array.from(document.querySelectorAll('[role="button"]'));
+            const confirmBtn = btnsAfter.find(btn => {
+              const t = btn.innerText.trim().toLowerCase();
+              return (t === 'accept' || t === '接受') && btn !== acceptBtn;
+            });
+            if (confirmBtn) {
+              confirmBtn.click();
+              await new Promise(r => setTimeout(r, 1000));
+            }
+
+            return { status: 'accepted', user: username, message: 'Accepted! Matched: ' + matchedKw.join(', ') };
+          } catch(e) {
+            return { status: 'error', user: 'system', message: String(e) };
+          }
+        })()`);
+                if (res?.status === 'accepted') {
+                    acceptCount++;
+                    foundInThisRound = true;
+                    results.push({
+                        index: acceptCount,
+                        status: 'accepted',
+                        user: res.user || 'Unknown',
+                        message: res.message || 'Accepted',
+                    });
+                    // After accept, Twitter redirects to /messages — loop back to /messages/requests
+                    await page.wait(2);
+                    break; // break inner loop, outer loop will re-navigate to requests
+                }
+                else if (res?.status === 'no_button') {
+                    // Already accepted, skip
+                    continue;
+                }
+            }
+            // If no match found in this round, we've exhausted all visible requests
+            if (!foundInThisRound) {
+                break;
+            }
+        }
+        if (results.length === 0) {
+            results.push({ index: 0, status: 'info', user: 'System', message: `No requests matched keywords "${keywords.join(', ')}"` });
+        }
+        return results;
+    }
+});

package/vendor/opencli/dist/clis/twitter/article.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/twitter/article.js

@@ -0,0 +1,163 @@
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { resolveTwitterQueryId } from './shared.js';
+const TWEET_RESULT_BY_REST_ID_QUERY_ID = '7xflPyRiUxGVbJd4uWmbfg';
+cli({
+    site: 'twitter',
+    name: 'article',
+    description: 'Fetch a Twitter Article (long-form content) and export as Markdown',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'tweet-id', type: 'string', positional: true, required: true, help: 'Tweet ID or URL containing the article' },
+    ],
+    columns: ['title', 'author', 'content', 'url'],
+    func: async (page, kwargs) => {
+        // Extract tweet ID from URL if needed.
+        // Article URLs (x.com/i/article/{articleId}) use a different ID than
+        // tweet status URLs — the GraphQL endpoint needs the parent tweet ID.
+        let tweetId = kwargs['tweet-id'];
+        const isArticleUrl = /\/article\/\d+/.test(tweetId);
+        const urlMatch = tweetId.match(/\/(?:status|article)\/(\d+)/);
+        if (urlMatch)
+            tweetId = urlMatch[1];
+        if (isArticleUrl) {
+            // Navigate to the article page and resolve the parent tweet ID from DOM
+            await page.goto(`https://x.com/i/article/${tweetId}`);
+            await page.wait(3);
+            const resolvedId = await page.evaluate(`
+        (function() {
+          var links = document.querySelectorAll('a[href*="/status/"]');
+          for (var i = 0; i < links.length; i++) {
+            var m = links[i].href.match(/\\/status\\/(\\d+)/);
+            if (m) return m[1];
+          }
+          var og = document.querySelector('meta[property="og:url"]');
+          if (og && og.content) {
+            var m2 = og.content.match(/\\/status\\/(\\d+)/);
+            if (m2) return m2[1];
+          }
+          return null;
+        })()
+      `);
+            if (!resolvedId || typeof resolvedId !== 'string') {
+                throw new CommandExecutionError(`Could not resolve article ${tweetId} to a tweet ID. The article page may not contain a linked tweet.`);
+            }
+            tweetId = resolvedId;
+        }
+        // Navigate to the tweet page for cookie context
+        await page.goto(`https://x.com/i/status/${tweetId}`);
+        await page.wait(3);
+        const queryId = await resolveTwitterQueryId(page, 'TweetResultByRestId', TWEET_RESULT_BY_REST_ID_QUERY_ID);
+        const result = await page.evaluate(`
+      async () => {
+        const tweetId = "${tweetId}";
+        const ct0 = document.cookie.split(';').map(c=>c.trim()).find(c=>c.startsWith('ct0='))?.split('=')[1];
+        if (!ct0) return {error: 'No ct0 cookie — not logged into x.com'};
+
+        const bearer = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+        const headers = {
+          'Authorization': 'Bearer ' + decodeURIComponent(bearer),
+          'X-Csrf-Token': ct0,
+          'X-Twitter-Auth-Type': 'OAuth2Session',
+          'X-Twitter-Active-User': 'yes'
+        };
+
+        const variables = JSON.stringify({
+          tweetId: tweetId,
+          withCommunity: false,
+          includePromotedContent: false,
+          withVoice: false,
+        });
+        const features = JSON.stringify({
+          longform_notetweets_consumption_enabled: true,
+          responsive_web_twitter_article_tweet_consumption_enabled: true,
+          longform_notetweets_rich_text_read_enabled: true,
+          longform_notetweets_inline_media_enabled: true,
+          articles_preview_enabled: true,
+          responsive_web_graphql_exclude_directive_enabled: true,
+          verified_phone_label_enabled: false,
+        });
+        const fieldToggles = JSON.stringify({
+          withArticleRichContentState: true,
+          withArticlePlainText: true,
+        });
+
+        const url = '/i/api/graphql/' + ${JSON.stringify(queryId)} + '/TweetResultByRestId?variables='
+          + encodeURIComponent(variables)
+          + '&features=' + encodeURIComponent(features)
+          + '&fieldToggles=' + encodeURIComponent(fieldToggles);
+
+        const resp = await fetch(url, {headers, credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status, hint: 'Tweet may not exist or queryId expired'};
+        const d = await resp.json();
+
+        const result = d.data?.tweetResult?.result;
+        if (!result) return {error: 'Article not found'};
+
+        // Unwrap TweetWithVisibilityResults
+        const tw = result.tweet || result;
+        const legacy = tw.legacy || {};
+        const user = tw.core?.user_results?.result;
+        const screenName = user?.legacy?.screen_name || user?.core?.screen_name || 'unknown';
+
+        // Extract article content
+        const articleResults = tw.article?.article_results?.result;
+        if (!articleResults) {
+          // Fallback: return note_tweet text if present
+          const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
+          if (noteText) {
+            return [{
+              title: '(Note Tweet)',
+              author: screenName,
+              content: noteText,
+              url: 'https://x.com/' + screenName + '/status/' + tweetId,
+            }];
+          }
+          return {error: 'Tweet ' + tweetId + ' has no article content'};
+        }
+
+        const title = articleResults.title || '(Untitled)';
+        const contentState = articleResults.content_state || {};
+        const blocks = contentState.blocks || [];
+
+        // Convert draft.js blocks to Markdown
+        const parts = [];
+        let orderedCounter = 0;
+        for (const block of blocks) {
+          const blockType = block.type || 'unstyled';
+          if (blockType === 'atomic') continue;
+          const text = block.text || '';
+          if (!text) continue;
+          if (blockType !== 'ordered-list-item') orderedCounter = 0;
+
+          if (blockType === 'header-one')           parts.push('# ' + text);
+          else if (blockType === 'header-two')      parts.push('## ' + text);
+          else if (blockType === 'header-three')    parts.push('### ' + text);
+          else if (blockType === 'blockquote')       parts.push('> ' + text);
+          else if (blockType === 'unordered-list-item') parts.push('- ' + text);
+          else if (blockType === 'ordered-list-item') {
+            orderedCounter++;
+            parts.push(orderedCounter + '. ' + text);
+          }
+          else if (blockType === 'code-block')       parts.push('\`\`\`\\n' + text + '\\n\`\`\`');
+          else                                       parts.push(text);
+        }
+
+        return [{
+          title,
+          author: screenName,
+          content: parts.join('\\n\\n') || legacy.full_text || '',
+          url: 'https://x.com/' + screenName + '/status/' + tweetId,
+        }];
+      }
+    `);
+        if (result?.error) {
+            if (String(result.error).includes('No ct0 cookie'))
+                throw new AuthRequiredError('x.com', result.error);
+            throw new CommandExecutionError(result.error + (result.hint ? ` (${result.hint})` : ''));
+        }
+        return result || [];
+    }
+});

package/vendor/opencli/dist/clis/twitter/block.d.ts

@@ -0,0 +1 @@
+export {};