@zenalexa/unicli 0.207.1

package/src/adapters/tiktok/profile.yaml

@@ -0,0 +1,47 @@
+site: tiktok
+name: profile
+description: Get TikTok user profile info
+domain: www.tiktok.com
+strategy: intercept
+browser: true
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: TikTok username (without @)
+
+columns: [username, name, followers, following, likes, videos, verified, bio]
+
+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',
+        }];
+      })()

package/src/adapters/tiktok/save.yaml

@@ -0,0 +1,36 @@
+site: tiktok
+name: save
+description: Add a TikTok video to Favorites
+domain: www.tiktok.com
+strategy: intercept
+browser: true
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+
+columns: [status, 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 }];
+      })()

package/src/adapters/tiktok/search.yaml

@@ -0,0 +1,49 @@
+site: tiktok
+name: search
+description: Search TikTok videos
+domain: www.tiktok.com
+strategy: intercept
+browser: true
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Search query
+  limit:
+    type: int
+    default: 10
+    description: Number of results
+
+columns: [rank, desc, author, url, plays, likes, comments, shares]
+
+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,
+          };
+        });
+      })()

package/src/adapters/tiktok/unfollow.yaml

@@ -0,0 +1,45 @@
+site: tiktok
+name: unfollow
+description: Unfollow a TikTok user
+domain: www.tiktok.com
+strategy: intercept
+browser: true
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: TikTok username (without @)
+
+columns: [status, username]
+
+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));
+        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 }];
+      })()

package/src/adapters/tiktok/unlike.yaml

@@ -0,0 +1,40 @@
+site: tiktok
+name: unlike
+description: Unlike a TikTok video
+domain: www.tiktok.com
+strategy: intercept
+browser: true
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+
+columns: [status, likes, 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 }];
+      })()

package/src/adapters/tiktok/unsave.yaml

@@ -0,0 +1,38 @@
+site: tiktok
+name: unsave
+description: Remove a TikTok video from Favorites
+domain: www.tiktok.com
+strategy: intercept
+browser: true
+
+args:
+  url:
+    type: str
+    required: true
+    positional: true
+    description: TikTok video URL
+
+columns: [status, 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 }];
+      })()

package/src/adapters/tiktok/user.yaml

@@ -0,0 +1,46 @@
+site: tiktok
+name: user
+description: Get recent videos from a TikTok user
+domain: www.tiktok.com
+strategy: intercept
+browser: true
+
+args:
+  username:
+    type: str
+    required: true
+    positional: true
+    description: TikTok username (without @)
+  limit:
+    type: int
+    default: 10
+    description: Number of videos
+
+columns: [index, views, url]
+
+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;
+      })()

package/src/adapters/twitter/accept.ts

@@ -0,0 +1,73 @@
+/**
+ * Twitter accept — accept a pending follow request via REST API.
+ *
+ * Uses the v1.1 REST endpoint since there is no public GraphQL mutation for this.
+ */
+
+import { cli } from "../../registry.js";
+import { Strategy } from "../../types.js";
+import { loadCookies, formatCookieHeader } from "../../engine/cookies.js";
+import { USER_AGENT } from "../../constants.js";
+
+const BEARER_TOKEN =
+  "AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA";
+
+cli({
+  site: "twitter",
+  name: "accept",
+  description: "Accept a pending follow request",
+  domain: "x.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "user_id",
+      required: true,
+      positional: true,
+      description: "User numeric ID whose follow request to accept",
+    },
+  ],
+  columns: ["status", "id"],
+  func: async (_page, kwargs) => {
+    const userId = String(kwargs.user_id);
+
+    const cookies = loadCookies("twitter");
+    if (!cookies) {
+      throw new Error(
+        'No cookies found for "twitter". Run: unicli auth setup twitter',
+      );
+    }
+
+    const ct0 = cookies.ct0;
+    if (!ct0) {
+      throw new Error(
+        "Missing ct0 cookie (CSRF token). " +
+          "Ensure ~/.unicli/cookies/twitter.json contains ct0 and auth_token.",
+      );
+    }
+
+    const params = new URLSearchParams({ user_id: userId });
+    const url = `https://x.com/1.1/friendships/accept.json?${params.toString()}`;
+
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${BEARER_TOKEN}`,
+        "X-Csrf-Token": ct0,
+        "X-Twitter-Auth-Type": "OAuth2Session",
+        "X-Twitter-Active-User": "yes",
+        "User-Agent": USER_AGENT,
+        Cookie: formatCookieHeader(cookies),
+      },
+    });
+
+    if (!resp.ok) {
+      const preview = await resp.text().catch(() => "");
+      throw new Error(
+        `Twitter API error: HTTP ${resp.status} on accept\n` +
+          `${preview.slice(0, 200)}`,
+      );
+    }
+
+    return [{ status: "ok", id: userId }];
+  },
+});

package/src/adapters/twitter/article.ts

@@ -0,0 +1,141 @@
+/**
+ * Twitter article — fetch a Twitter article/note content via GraphQL TweetDetail.
+ */
+
+import { cli } from "../../registry.js";
+import { Strategy } from "../../types.js";
+import { twitterFetch, FEATURES } from "./client.js";
+
+const QUERY_ID = "xOhkmRac04YFZmOzU9PJHg";
+const ENDPOINT = "TweetDetail";
+
+cli({
+  site: "twitter",
+  name: "article",
+  description: "Get Twitter article/note content from a tweet",
+  domain: "x.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "tweet_id",
+      required: true,
+      positional: true,
+      description: "Tweet ID containing the article/note",
+    },
+  ],
+  columns: ["id", "author", "title", "text", "url"],
+  func: async (_page, kwargs) => {
+    const tweetId = String(kwargs.tweet_id);
+
+    const variables = {
+      focalTweetId: tweetId,
+      with_rux_injections: false,
+      includePromotedContent: false,
+      withCommunity: true,
+      withQuickPromoteEligibilityTweetFields: false,
+      withBirdwatchNotes: false,
+      withVoice: true,
+      withV2Timeline: true,
+    };
+
+    const data = (await twitterFetch(
+      ENDPOINT,
+      QUERY_ID,
+      variables,
+      FEATURES,
+    )) as Record<string, unknown>;
+
+    // Navigate: data.threaded_conversation_with_injections_v2.instructions
+    const root = data.data as Record<string, unknown> | undefined;
+    const conversation = root?.threaded_conversation_with_injections_v2 as
+      | Record<string, unknown>
+      | undefined;
+    const instructions = (conversation?.instructions as unknown[]) ?? [];
+
+    for (const instruction of instructions) {
+      const inst = instruction as Record<string, unknown>;
+      if ((inst.type as string) !== "TimelineAddEntries") continue;
+
+      const entries = (inst.entries as unknown[]) ?? [];
+      for (const entry of entries) {
+        const e = entry as Record<string, unknown>;
+        const content = e.content as Record<string, unknown> | undefined;
+        if (!content) continue;
+
+        const itemContent = content.itemContent as
+          | Record<string, unknown>
+          | undefined;
+        if (!itemContent) continue;
+
+        const tweetResults = itemContent.tweet_results as
+          | Record<string, unknown>
+          | undefined;
+        const result = tweetResults?.result as
+          | Record<string, unknown>
+          | undefined;
+        if (!result) continue;
+
+        // Unwrap tweet_with_visibility_results
+        const tweetObj = (result.tweet ?? result) as Record<string, unknown>;
+        const restId = tweetObj.rest_id as string | undefined;
+        if (restId !== tweetId) continue;
+
+        const core = tweetObj.core as Record<string, unknown> | undefined;
+        const userResults = core?.user_results as
+          | Record<string, unknown>
+          | undefined;
+        const userResult = userResults?.result as
+          | Record<string, unknown>
+          | undefined;
+        const userLegacy = userResult?.legacy as
+          | Record<string, unknown>
+          | undefined;
+        const screenName = (userLegacy?.screen_name as string) ?? "unknown";
+
+        // Extract note/article content from note_tweet
+        const noteTweet = tweetObj.note_tweet as
+          | Record<string, unknown>
+          | undefined;
+        const noteTweetResults = noteTweet?.note_tweet_results as
+          | Record<string, unknown>
+          | undefined;
+        const noteResult = noteTweetResults?.result as
+          | Record<string, unknown>
+          | undefined;
+        const noteText = (noteResult?.text as string) ?? "";
+
+        // Fallback to legacy full_text if no note content
+        const legacy = tweetObj.legacy as Record<string, unknown> | undefined;
+        const fullText = (legacy?.full_text as string) ?? "";
+
+        const articleText = noteText || fullText;
+
+        // Extract title from card if present
+        const card = tweetObj.card as Record<string, unknown> | undefined;
+        const cardLegacy = card?.legacy as Record<string, unknown> | undefined;
+        const bindingValues = (cardLegacy?.binding_values as unknown[]) ?? [];
+
+        let title = "";
+        for (const bv of bindingValues) {
+          const binding = bv as Record<string, unknown>;
+          if ((binding.key as string) === "title") {
+            const stringValue = binding.string_value as string | undefined;
+            if (stringValue) title = stringValue;
+          }
+        }
+
+        return [
+          {
+            id: restId,
+            author: screenName,
+            title,
+            text: articleText,
+            url: `https://x.com/${screenName}/status/${restId}`,
+          },
+        ];
+      }
+    }
+
+    return [];
+  },
+});

package/src/adapters/twitter/block.ts

@@ -0,0 +1,38 @@
+/**
+ * Twitter block — block a user via GraphQL mutation.
+ */
+
+import { cli } from "../../registry.js";
+import { Strategy } from "../../types.js";
+import { twitterPostFetch, FEATURES } from "./client.js";
+
+const QUERY_ID = "jMC-Mp2csnPBMsLij4JcsQ";
+const ENDPOINT = "BlockUser";
+
+cli({
+  site: "twitter",
+  name: "block",
+  description: "Block a user",
+  domain: "x.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "user_id",
+      required: true,
+      positional: true,
+      description: "User numeric ID to block",
+    },
+  ],
+  columns: ["status", "id"],
+  func: async (_page, kwargs) => {
+    const userId = String(kwargs.user_id);
+
+    const variables = {
+      user_id: userId,
+    };
+
+    await twitterPostFetch(ENDPOINT, QUERY_ID, variables, FEATURES);
+
+    return [{ status: "ok", id: userId }];
+  },
+});

package/src/adapters/twitter/bookmark.ts

@@ -0,0 +1,38 @@
+/**
+ * Twitter bookmark — bookmark a tweet via GraphQL mutation.
+ */
+
+import { cli } from "../../registry.js";
+import { Strategy } from "../../types.js";
+import { twitterPostFetch, FEATURES } from "./client.js";
+
+const QUERY_ID = "aoDbu3RHznuiSkQ9aNM67Q";
+const ENDPOINT = "BookmarkTweet";
+
+cli({
+  site: "twitter",
+  name: "bookmark",
+  description: "Bookmark a tweet",
+  domain: "x.com",
+  strategy: Strategy.COOKIE,
+  args: [
+    {
+      name: "tweet_id",
+      required: true,
+      positional: true,
+      description: "Tweet ID to bookmark",
+    },
+  ],
+  columns: ["status", "id"],
+  func: async (_page, kwargs) => {
+    const tweetId = String(kwargs.tweet_id);
+
+    const variables = {
+      tweet_id: tweetId,
+    };
+
+    await twitterPostFetch(ENDPOINT, QUERY_ID, variables, FEATURES);
+
+    return [{ status: "ok", id: tweetId }];
+  },
+});

package/src/adapters/twitter/bookmarks.ts

@@ -0,0 +1,50 @@
+/**
+ * Twitter bookmarks — fetch authenticated user's bookmarks via GraphQL.
+ */
+
+import { cli } from "../../registry.js";
+import { Strategy } from "../../types.js";
+import {
+  twitterFetch,
+  FEATURES,
+  extractTweetsFromInstructions,
+} from "./client.js";
+
+const QUERY_ID = "vOVTxp4izPYJBqbq8tpJCg";
+const ENDPOINT = "Bookmarks";
+
+cli({
+  site: "twitter",
+  name: "bookmarks",
+  description: "Get your bookmarked tweets",
+  domain: "x.com",
+  strategy: Strategy.COOKIE,
+  columns: ["id", "author", "text", "likes", "retweets", "views", "url"],
+  func: async (_page, kwargs) => {
+    const count = Math.min((kwargs.limit as number) ?? 20, 50);
+
+    const variables = {
+      count,
+      includePromotedContent: false,
+    };
+
+    const data = (await twitterFetch(
+      ENDPOINT,
+      QUERY_ID,
+      variables,
+      FEATURES,
+    )) as Record<string, unknown>;
+
+    // Navigate: data.bookmark_timeline_v2.timeline.instructions
+    const root = data.data as Record<string, unknown> | undefined;
+    const bookmarkTimeline = root?.bookmark_timeline_v2 as
+      | Record<string, unknown>
+      | undefined;
+    const timeline = bookmarkTimeline?.timeline as
+      | Record<string, unknown>
+      | undefined;
+    const instructions = (timeline?.instructions as unknown[]) ?? [];
+
+    return extractTweetsFromInstructions(instructions);
+  },
+});