bell-feed-mcp 0.1.0__tar.gz

bell_feed_mcp-0.1.0/.claude/skills/crypto-intel/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: crypto-intel
+description: Get crypto Twitter intelligence from Bell Feed — summaries, signals, trending tokens
+user_invocable: true
+---
+
+# Crypto Intel — Bell Feed Intelligence
+
+Provide crypto Twitter intelligence from Bell Feed data (data.degendar.com).
+
+## Arguments
+
+- No args or `latest` → Show latest summaries + trading signals
+- `trending` → Show trending tokens ranked by mention frequency
+- `search <query>` → Search summaries by keyword (e.g., `search SOL`)
+- `tldr` → Show today's TL;DR summary
+
+## Execution
+
+### Step 1: Determine Mode
+
+Parse the user's argument to determine which mode to use:
+- Default/`latest` → latest summaries
+- `trending` → trending tokens
+- `search <query>` → keyword search
+- `tldr` → daily TL;DR
+
+### Step 2: Fetch Data
+
+**If Bell Feed MCP tools are available** (check for `get_latest_summaries`, `get_trending_tokens`, `get_daily_tldr`, `search_summaries` tools):
+
+- `latest` → call `get_latest_summaries(count=5)`
+- `trending` → call `get_trending_tokens(hours=24)`
+- `search <query>` → call `search_summaries(query="<query>", max_results=10)`
+- `tldr` → call `get_daily_tldr()`
+
+**If MCP tools are NOT available**, fallback to curl:
+
+- `latest` → `curl -s https://data.degendar.com/summaries.json | python3 -c "import sys,json; d=json.load(sys.stdin)[:5]; print(json.dumps(d,ensure_ascii=False,indent=2))"`
+- `trending` → `curl -s https://data.degendar.com/summaries.json | python3 -c "
+import sys,json
+from collections import Counter
+from datetime import datetime,timezone
+summaries=json.load(sys.stdin)
+cutoff=datetime.now(timezone.utc).timestamp()-86400
+counts=Counter()
+for s in summaries:
+    try:
+        ts=datetime.fromisoformat(s['timestamp']).timestamp()
+    except: continue
+    if ts>=cutoff:
+        counts.update(s.get('tokens',[]))
+for t,c in counts.most_common(20):
+    print(f'{t}: {c} mentions')
+"`
+- `search <query>` → `curl -s https://data.degendar.com/summaries.json | python3 -c "
+import sys,json
+q='<query>'.lower()
+for s in json.load(sys.stdin):
+    text=(s.get('summary_text','')+' '+s.get('signals','')+' '+' '.join(s.get('tokens',[]))).lower()
+    if q in text:
+        print(f\"[{s['id']}] {s.get('summary_text','')[:150]}\")
+        if s.get('signals'): print(f'  Signals: {s[\"signals\"]}')
+        print()
+"`
+- `tldr` → `curl -s https://data.degendar.com/daily_tldr.json`
+
+### Step 3: Format Output
+
+Present the results clearly in 繁體中文:
+
+- **Latest**: Show each summary with timestamp, summary text, trading signals, and mentioned tokens
+- **Trending**: Show a ranked table of tokens with mention counts
+- **Search**: Show matching summaries with highlighted context
+- **TL;DR**: Show the daily summary directly

bell_feed_mcp-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+state.json
+chrome_profile/
+debug_login.png
+output/
+__pycache__/
+*.pyc
+.env
+.venv/

bell_feed_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: bell-feed-mcp
+Version: 0.1.0
+Summary: MCP server for Bell Feed — crypto Twitter intelligence
+Requires-Python: >=3.10
+Requires-Dist: mcp

bell_feed_mcp-0.1.0/analyze_archive.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""分析 Twitter archive 資料"""
+
+import json
+import os
+import re
+import sys
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+BOOKMARKS_PATH = Path(__file__).parent / "output" / "bookmarks.json"
+OUTPUT_PATH = Path(__file__).parent / "output" / "analysis.md"
+
+
+def find_archive_dir() -> Path:
+    docs = Path.home() / "Documents"
+    matches = list(docs.glob("twitter-*"))
+    if not matches:
+        print("ERROR: 找不到 Twitter archive，請放在 ~/Documents/twitter-*")
+        sys.exit(1)
+    return matches[0] / "data"
+
+
+def load_js(archive_dir: Path, filename: str) -> list:
+    path = archive_dir / filename
+    text = path.read_text(encoding="utf-8")
+    json_start = text.index("[")
+    return json.loads(text[json_start:])
+
+
+def load_bookmarks() -> set[str]:
+    if not BOOKMARKS_PATH.exists():
+        return set()
+    data = json.loads(BOOKMARKS_PATH.read_text(encoding="utf-8"))
+    return {t["tweet_id"] for t in data if t.get("tweet_id")}
+
+
+def analyze_tweets(tweets_raw: list) -> str:
+    lines = [f"## Your Tweets ({len(tweets_raw)})\n"]
+
+    tweets = []
+    for item in tweets_raw:
+        t = item["tweet"]
+        created = datetime.strptime(t["created_at"], "%a %b %d %H:%M:%S %z %Y")
+        tweets.append({
+            "text": t["full_text"],
+            "likes": int(t.get("favorite_count", 0)),
+            "rts": int(t.get("retweet_count", 0)),
+            "lang": t.get("lang", ""),
+            "created_at": created,
+            "hour": created.hour,
+            "weekday": created.strftime("%A"),
+            "is_rt": t["full_text"].startswith("RT @"),
+            "is_reply": t["full_text"].startswith("@"),
+            "mentions": [m["screen_name"] for m in t.get("entities", {}).get("user_mentions", [])],
+            "hashtags": [h["text"] for h in t.get("entities", {}).get("hashtags", [])],
+            "source": re.sub(r"<[^>]+>", "", t.get("source", "")),
+        })
+
+    original = [t for t in tweets if not t["is_rt"]]
+    rts = [t for t in tweets if t["is_rt"]]
+
+    lines.append(f"- Original: {len(original)} | RT: {len(rts)}")
+    lines.append(f"- Date range: {min(t['created_at'] for t in tweets).strftime('%Y-%m-%d')} ~ {max(t['created_at'] for t in tweets).strftime('%Y-%m-%d')}")
+
+    lang_counter = Counter(t["lang"] for t in original)
+    lines.append(f"- Languages: {', '.join(f'{lang}({cnt})' for lang, cnt in lang_counter.most_common(5))}")
+
+    source_counter = Counter(t["source"] for t in tweets)
+    lines.append(f"- Devices: {', '.join(f'{s}({c})' for s, c in source_counter.most_common(3))}")
+
+    lines.append("\n### Top Engagement (Original Tweets)\n")
+    lines.append("| Likes | RTs | Text |")
+    lines.append("|-------|-----|------|")
+    top = sorted(original, key=lambda t: t["likes"] + t["rts"], reverse=True)[:15]
+    for t in top:
+        text = t["text"][:80].replace("\n", " ").replace("|", "\\|")
+        lines.append(f"| {t['likes']} | {t['rts']} | {text} |")
+
+    lines.append("\n### Posting Time (UTC)\n")
+    hour_counter = Counter(t["hour"] for t in tweets)
+    max_count = max(hour_counter.values()) if hour_counter else 1
+    for hour in range(24):
+        cnt = hour_counter.get(hour, 0)
+        bar = "█" * int(cnt / max_count * 20) if cnt else ""
+        lines.append(f"  {hour:02d}:00  {bar} {cnt}")
+
+    lines.append("\n### Day of Week\n")
+    day_order = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+    day_counter = Counter(t["weekday"] for t in tweets)
+    for day in day_order:
+        cnt = day_counter.get(day, 0)
+        lines.append(f"  {day:<10} {'█' * int(cnt / max(day_counter.values()) * 15)} {cnt}")
+
+    lines.append("\n### Most Mentioned Users\n")
+    mention_counter = Counter()
+    for t in tweets:
+        mention_counter.update(t["mentions"])
+    for user, cnt in mention_counter.most_common(15):
+        lines.append(f"  @{user} — {cnt} times")
+
+    lines.append("\n### Top Hashtags\n")
+    hashtag_counter = Counter()
+    for t in tweets:
+        hashtag_counter.update(t["hashtags"])
+    if hashtag_counter:
+        for tag, cnt in hashtag_counter.most_common(15):
+            lines.append(f"  #{tag} — {cnt}")
+    else:
+        lines.append("  (none)")
+
+    return "\n".join(lines)
+
+
+def analyze_likes(likes_raw: list, bookmark_ids: set[str]) -> str:
+    lines = [f"## Likes ({len(likes_raw)})\n"]
+
+    likes = []
+    for item in likes_raw:
+        li = item["like"]
+        likes.append({
+            "tweet_id": li["tweetId"],
+            "text": li.get("fullText", ""),
+        })
+
+    liked_ids = {l["tweet_id"] for l in likes}
+    overlap = liked_ids & bookmark_ids
+    liked_only = liked_ids - bookmark_ids
+    bookmarked_only = bookmark_ids - liked_ids
+
+    lines.append(f"- Total likes: {len(likes)}")
+    lines.append(f"- Total bookmarks: {len(bookmark_ids)}")
+    lines.append(f"- Liked AND bookmarked: {len(overlap)}")
+    lines.append(f"- Liked but NOT bookmarked: {len(liked_only)}")
+    lines.append(f"- Bookmarked but NOT liked: {len(bookmarked_only)}")
+
+    lines.append("\n### Keyword Frequency in Liked Tweets\n")
+    word_counter = Counter()
+    stop_words = {"the", "a", "an", "is", "are", "was", "were", "be", "to", "of", "and", "in",
+                  "that", "it", "for", "on", "with", "as", "at", "by", "this", "from", "or",
+                  "not", "but", "you", "your", "i", "my", "me", "we", "they", "he", "she",
+                  "do", "does", "did", "will", "would", "can", "could", "have", "has", "had",
+                  "rt", "https", "co", "t", "s", "amp", "just", "like", "so", "if", "all",
+                  "about", "what", "when", "how", "who", "which", "no", "more", "than",
+                  "been", "also", "其", "的", "了", "在", "是", "我", "不", "有", "這",
+                  "就", "都", "也", "人", "他", "她", "們", "要", "會", "很", "你",
+                  "一", "個", "上", "嗎", "吧", "啊", "呢", "把", "被", "讓", "給",
+                  "而", "但", "又", "還", "到", "去", "來", "著", "過", "得", "能",
+                  "可以", "因為", "所以", "如果", "那", "什麼", "沒有", "自己"}
+
+    for li in likes:
+        text = li["text"].lower()
+        text = re.sub(r"https?://\S+", "", text)
+        text = re.sub(r"@\w+", "", text)
+        words = re.findall(r"[a-z]{3,}|[\u4e00-\u9fff]{2,}", text)
+        word_counter.update(w for w in words if w not in stop_words)
+
+    for word, cnt in word_counter.most_common(30):
+        lines.append(f"  {word} — {cnt}")
+
+    return "\n".join(lines)
+
+
+def analyze_following(following_raw: list, follower_raw: list) -> str:
+    lines = ["## Social Graph\n"]
+
+    following_ids = {f["following"]["accountId"] for f in following_raw}
+    follower_ids = {f["follower"]["accountId"] for f in follower_raw}
+
+    mutual = following_ids & follower_ids
+    following_only = following_ids - follower_ids
+    follower_only = follower_ids - following_ids
+
+    lines.append(f"- Following: {len(following_ids)}")
+    lines.append(f"- Followers: {len(follower_ids)}")
+    lines.append(f"- Mutual: {len(mutual)}")
+    lines.append(f"- You follow but they don't follow back: {len(following_only)}")
+    lines.append(f"- They follow you but you don't follow back: {len(follower_only)}")
+    lines.append(f"- Follow-back ratio: {len(mutual) / len(following_ids) * 100:.1f}%")
+
+    return "\n".join(lines)
+
+
+def main():
+    archive_dir = find_archive_dir()
+    print(f"→ Loading archive from {archive_dir.parent.name}...")
+
+    tweets_raw = load_js(archive_dir, "tweets.js")
+    likes_raw = load_js(archive_dir, "like.js")
+    following_raw = load_js(archive_dir, "following.js")
+    follower_raw = load_js(archive_dir, "follower.js")
+    bookmark_ids = load_bookmarks()
+
+    print(f"  Tweets: {len(tweets_raw)}, Likes: {len(likes_raw)}, Following: {len(following_raw)}, Followers: {len(follower_raw)}, Bookmarks: {len(bookmark_ids)}")
+
+    sections = [
+        f"# Twitter Archive Analysis\n\nGenerated: {datetime.now().strftime('%Y-%m-%d %H:%M')}\n",
+        analyze_tweets(tweets_raw),
+        analyze_likes(likes_raw, bookmark_ids),
+        analyze_following(following_raw, follower_raw),
+    ]
+
+    report = "\n\n---\n\n".join(sections)
+    OUTPUT_PATH.write_text(report, encoding="utf-8")
+    print(f"\n→ Report saved: {OUTPUT_PATH}")
+    print(report)
+
+
+if __name__ == "__main__":
+    main()

bell_feed_mcp-0.1.0/export_bookmarks.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""X Bookmarks Export — 直接呼叫 GraphQL API"""
+
+import csv
+import html
+import json
+import os
+import random
+import sys
+import time
+import urllib.parse
+from datetime import datetime
+from pathlib import Path
+
+import httpx
+
+OUTPUT_DIR = Path(__file__).parent / "output"
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+GRAPHQL_URL = "https://x.com/i/api/graphql/tmd4ifV8RHltzn8ymGg1aw/Bookmarks"
+
+FEATURES = {
+    "graphql_timeline_v2_bookmark_timeline": True,
+    "rweb_tipjar_consumption_enabled": True,
+    "responsive_web_graphql_exclude_directive_enabled": True,
+    "verified_phone_label_enabled": False,
+    "creator_subscriptions_tweet_preview_api_enabled": True,
+    "responsive_web_graphql_timeline_navigation_enabled": True,
+    "responsive_web_graphql_skip_user_profile_image_extensions_enabled": False,
+    "communities_web_enable_tweet_community_results_fetch": True,
+    "c9s_tweet_anatomy_moderator_badge_enabled": True,
+    "articles_preview_enabled": True,
+    "responsive_web_edit_tweet_api_enabled": True,
+    "tweetypie_unmention_optimization_enabled": True,
+    "responsive_web_enhance_cards_enabled": False,
+    "responsive_web_media_download_video_enabled": False,
+    "responsive_web_twitter_article_tweet_consumption_enabled": True,
+    "tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled": True,
+    "creator_subscriptions_quote_tweet_preview_enabled": False,
+    "freedom_of_speech_not_reach_fetch_enabled": True,
+    "standardized_nudges_misinfo": True,
+    "tweet_awards_web_tipping_enabled": False,
+    "longform_notetweets_inline_media_enabled": True,
+    "longform_notetweets_rich_text_read_enabled": True,
+    "longform_notetweets_consumption_enabled": True,
+    "responsive_web_twitter_blue_verified_badge_is_enabled": True,
+    "view_counts_everywhere_api_enabled": True,
+}
+
+
+def parse_tweet(tweet_result: dict) -> dict | None:
+    if tweet_result.get("__typename") == "TweetWithVisibilityResults":
+        tweet_result = tweet_result.get("tweet", {})
+
+    if tweet_result.get("__typename") != "Tweet":
+        return None
+
+    core = tweet_result.get("core", {})
+    user_results = core.get("user_results", {}).get("result", {})
+    legacy_user = user_results.get("legacy", {})
+    legacy = tweet_result.get("legacy", {})
+
+    retweeted = legacy.get("retweeted_status_result", {}).get("result", {})
+    if retweeted:
+        rt_legacy = retweeted.get("legacy", {})
+        if retweeted.get("__typename") == "TweetWithVisibilityResults":
+            rt_legacy = retweeted.get("tweet", {}).get("legacy", {})
+        full_text = rt_legacy.get("full_text", legacy.get("full_text", ""))
+    else:
+        full_text = legacy.get("full_text", "")
+
+    note_tweet = tweet_result.get("note_tweet", {}).get("note_tweet_results", {}).get("result", {})
+    if note_tweet:
+        full_text = note_tweet.get("text", full_text)
+
+    full_text = html.unescape(full_text)
+
+    tweet_id = legacy.get("id_str") or tweet_result.get("rest_id", "")
+    screen_name = legacy_user.get("screen_name", "")
+
+    media_entities = legacy.get("extended_entities", {}).get("media", [])
+    if not media_entities:
+        media_entities = legacy.get("entities", {}).get("media", [])
+    media_urls = []
+    for m in media_entities:
+        if m.get("type") in ("video", "animated_gif"):
+            variants = m.get("video_info", {}).get("variants", [])
+            mp4s = [v for v in variants if v.get("content_type") == "video/mp4"]
+            if mp4s:
+                best = max(mp4s, key=lambda v: v.get("bitrate", 0))
+                media_urls.append(best["url"])
+            else:
+                media_urls.append(m.get("media_url_https", ""))
+        else:
+            media_urls.append(m.get("media_url_https", ""))
+
+    created_at = legacy.get("created_at", "")
+    if created_at:
+        try:
+            dt = datetime.strptime(created_at, "%a %b %d %H:%M:%S %z %Y")
+            created_at = dt.isoformat()
+        except ValueError:
+            pass
+
+    return {
+        "tweet_id": tweet_id,
+        "author_handle": screen_name,
+        "author_name": legacy_user.get("name", ""),
+        "full_text": full_text,
+        "created_at": created_at,
+        "tweet_url": f"https://x.com/{screen_name}/status/{tweet_id}" if screen_name and tweet_id else "",
+        "likes": legacy.get("favorite_count", 0),
+        "retweets": legacy.get("retweet_count", 0),
+        "replies": legacy.get("reply_count", 0),
+        "views": tweet_result.get("views", {}).get("count", ""),
+        "media_urls": media_urls,
+        "lang": legacy.get("lang", ""),
+        "in_reply_to_handle": legacy.get("in_reply_to_screen_name", ""),
+    }
+
+
+def extract_bookmarks(data: dict) -> tuple[list[dict], str | None]:
+    tweets = []
+    cursor = None
+
+    timeline = (
+        data.get("data", {})
+        .get("bookmark_timeline_v2", {})
+        .get("timeline", {})
+    )
+
+    for instruction in timeline.get("instructions", []):
+        if instruction.get("type") == "TimelineAddEntries":
+            entries = instruction.get("entries", [])
+        elif instruction.get("type") == "TimelineAddToModule":
+            entries = instruction.get("moduleItems", [])
+        else:
+            continue
+
+        for entry in entries:
+            entry_id = entry.get("entryId", "")
+
+            if entry_id.startswith("cursor-bottom-"):
+                cursor = entry.get("content", {}).get("value")
+                continue
+
+            item_content = entry.get("content", {})
+            if item_content.get("entryType") == "TimelineTimelineItem":
+                tweet_result = (
+                    item_content.get("itemContent", {})
+                    .get("tweet_results", {})
+                    .get("result", {})
+                )
+                parsed = parse_tweet(tweet_result)
+                if parsed:
+                    tweets.append(parsed)
+            elif item_content.get("entryType") == "TimelineTimelineModule":
+                for sub_item in item_content.get("items", []):
+                    sub_content = sub_item.get("item", {}).get("itemContent", {})
+                    tweet_result = sub_content.get("tweet_results", {}).get("result", {})
+                    parsed = parse_tweet(tweet_result)
+                    if parsed:
+                        tweets.append(parsed)
+            else:
+                item_inner = entry.get("item", {}).get("itemContent", {})
+                tweet_result = item_inner.get("tweet_results", {}).get("result", {})
+                parsed = parse_tweet(tweet_result)
+                if parsed:
+                    tweets.append(parsed)
+
+    return tweets, cursor
+
+
+def export_markdown(tweets: list[dict]):
+    path = OUTPUT_DIR / "bookmarks.md"
+    if not tweets:
+        print("沒有資料可匯出")
+        return
+
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(f"# X Bookmarks ({len(tweets)} 則)\n\n")
+        for tweet in tweets:
+            date = tweet["created_at"][:10] if tweet["created_at"] else "unknown"
+            f.write(f"## [{tweet['author_name']} (@{tweet['author_handle']})]({tweet['tweet_url']})\n")
+            f.write(f"*{date}* | {tweet['likes']} likes | {tweet['retweets']} RT | {tweet['views']} views\n\n")
+            f.write(f"{tweet['full_text']}\n\n")
+            for url in tweet.get("media_urls", []):
+                if url.endswith(".mp4"):
+                    f.write(f"[Video]({url})\n")
+                else:
+                    f.write(f"![media]({url})\n")
+            f.write("\n---\n\n")
+
+    print(f"✓ Markdown 匯出: {path} ({len(tweets)} 則)")
+
+
+def export_json(tweets: list[dict]):
+    path = OUTPUT_DIR / "bookmarks.json"
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(tweets, f, ensure_ascii=False, indent=2)
+    print(f"✓ JSON 匯出: {path} ({len(tweets)} 則)")
+
+
+def export_csv(tweets: list[dict]):
+    path = OUTPUT_DIR / "bookmarks.csv"
+    if not tweets:
+        print("沒有資料可匯出")
+        return
+
+    fieldnames = [
+        "tweet_id", "author_handle", "author_name", "full_text",
+        "created_at", "tweet_url", "likes", "retweets", "replies",
+        "views", "media_urls", "lang", "in_reply_to_handle",
+    ]
+
+    with open(path, "w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for tweet in tweets:
+            row = {**tweet, "media_urls": " | ".join(tweet.get("media_urls", []))}
+            writer.writerow(row)
+
+    print(f"✓ CSV 匯出: {path} ({len(tweets)} 則)")
+
+
+def load_env():
+    env_path = Path(__file__).parent / ".env"
+    if not env_path.exists():
+        return
+    for line in env_path.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        os.environ.setdefault(key.strip(), value.strip())
+
+
+def main():
+    load_env()
+
+    auth_token = os.environ.get("AUTH_TOKEN") or input("auth_token: ").strip()
+    ct0 = os.environ.get("CT0") or input("ct0: ").strip()
+
+    if not auth_token or not ct0:
+        print("ERROR: auth_token 和 ct0 都必須提供")
+        sys.exit(1)
+
+    if os.environ.get("AUTH_TOKEN"):
+        print("→ 從 .env 讀取 auth credentials")
+
+    headers = {
+        "authorization": "Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA",
+        "x-csrf-token": ct0,
+        "cookie": f"auth_token={auth_token}; ct0={ct0}",
+        "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+        "x-twitter-active-user": "yes",
+        "x-twitter-client-language": "en",
+    }
+
+    existing_tweets: list[dict] = []
+    existing_ids: set[str] = set()
+    json_path = OUTPUT_DIR / "bookmarks.json"
+    if json_path.exists():
+        with open(json_path, encoding="utf-8") as f:
+            existing_tweets = json.load(f)
+        existing_ids = {t["tweet_id"] for t in existing_tweets if t.get("tweet_id")}
+        print(f"→ 載入既有資料: {len(existing_tweets)} 則")
+
+    all_tweets: list[dict] = []
+    seen_ids: set[str] = set()
+    cursor: str | None = None
+    page_num = 0
+    hit_existing = False
+
+    print("→ 開始抓取新書籤...\n")
+
+    with httpx.Client(headers=headers, timeout=30) as client:
+        while True:
+            page_num += 1
+            variables: dict = {"count": 100}
+            if cursor:
+                variables["cursor"] = cursor
+
+            params = {
+                "variables": json.dumps(variables),
+                "features": json.dumps(FEATURES),
+            }
+
+            resp = client.get(GRAPHQL_URL, params=params)
+
+            if resp.status_code == 429:
+                print("  ⚠ Rate limited，等待 60 秒...")
+                time.sleep(60)
+                continue
+
+            if resp.status_code != 200:
+                print(f"  ERROR: HTTP {resp.status_code}")
+                print(f"  {resp.text[:500]}")
+                break
+
+            data = resp.json()
+
+            if "errors" in data:
+                print(f"  API 錯誤: {data['errors']}")
+                break
+
+            tweets, next_cursor = extract_bookmarks(data)
+
+            new_count = 0
+            for tweet in tweets:
+                tid = tweet["tweet_id"]
+                if tid and tid in existing_ids:
+                    hit_existing = True
+                    continue
+                if tid and tid not in seen_ids:
+                    seen_ids.add(tid)
+                    all_tweets.append(tweet)
+                    new_count += 1
+
+            print(f"  第 {page_num} 頁: 取得 {len(tweets)} 則（新增 {new_count}），累計: {len(all_tweets)}")
+
+            if hit_existing:
+                print("  → 遇到已存在的書籤，停止抓取")
+                break
+
+            if not next_cursor or new_count == 0:
+                break
+
+            cursor = next_cursor
+            delay = random.uniform(2.0, 5.0)
+            time.sleep(delay)
+
+    if all_tweets:
+        print(f"\n→ 新增 {len(all_tweets)} 則書籤")
+        all_tweets.extend(existing_tweets)
+    else:
+        print("\n→ 沒有新書籤")
+        all_tweets = existing_tweets
+
+    print(f"→ 總計 {len(all_tweets)} 則書籤")
+
+    all_tweets.sort(key=lambda t: t.get("created_at", ""), reverse=True)
+
+    export_json(all_tweets)
+    export_csv(all_tweets)
+    export_markdown(all_tweets)
+
+    print("\n完成 ✓")
+
+
+if __name__ == "__main__":
+    main()