@cm-growth-hacking/twitter-client 0.2.0

package/bin/twitter.js

@@ -0,0 +1,1129 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/client/query-ids.ts
+var exports_query_ids = {};
+__export(exports_query_ids, {
+  queryIdManager: () => queryIdManager,
+  QueryIdManager: () => QueryIdManager
+});
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+
+class QueryIdManager {
+  cache = {};
+  constructor() {
+    this.loadCache();
+  }
+  loadCache() {
+    try {
+      const content = readFileSync(CACHE_PATH, "utf-8");
+      const data = JSON.parse(content);
+      if (data.version !== CACHE_VERSION) {
+        return;
+      }
+      if (data.timestamp && Date.now() - data.timestamp > CACHE_TTL) {
+        return;
+      }
+      this.cache = data.queryIds || {};
+    } catch {
+      this.cache = {};
+    }
+  }
+  saveCache(queryIds) {
+    try {
+      const dir = dirname(CACHE_PATH);
+      mkdirSync(dir, { recursive: true });
+      const data = {
+        version: CACHE_VERSION,
+        timestamp: Date.now(),
+        queryIds
+      };
+      writeFileSync(CACHE_PATH, JSON.stringify(data, null, 2));
+    } catch (error) {
+      console.warn(`Failed to save query ID cache: ${error}`);
+    }
+  }
+  getQueryId(operation) {
+    if (this.cache[operation]) {
+      return this.cache[operation];
+    }
+    if (BAKED_IDS[operation]) {
+      return BAKED_IDS[operation];
+    }
+    throw new Error(`Unknown operation: ${operation}`);
+  }
+  async scrapeQueryIds() {
+    const operations = Object.keys(BAKED_IDS);
+    const queryIds = {};
+    const bundleUrl = "https://abs.twimg.com/responsive-web/client-web/main." + Date.now() + ".js";
+    try {
+      const response = await fetch(bundleUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch bundle: ${response.status}`);
+      }
+      const js = await response.text();
+      for (const op of operations) {
+        const patterns = [
+          new RegExp(`"${op}":"([A-Za-z0-9]+)"`, "g"),
+          new RegExp(`queryId:\\s*"([A-Za-z0-9]+)"\\s*,\\s*\\w*:\\s*\\w*:\\s*\\{\\s*"name":\\s*"${op}"`, "g"),
+          new RegExp(`"queryId":\\s*"([A-Za-z0-9]+)"`, "g")
+        ];
+        for (const pattern of patterns) {
+          const matches = js.matchAll(pattern);
+          const ids = Array.from(matches).map((m) => m[1]).filter((id) => id.length >= 15 && id.length <= 25);
+          if (ids.length > 0) {
+            queryIds[op] = ids[0];
+            break;
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Scraping failed, using baked-in IDs: ${error}`);
+      for (const op of operations) {
+        const id = BAKED_IDS[op];
+        queryIds[op] = Array.isArray(id) ? id[0] : id;
+      }
+    }
+    return queryIds;
+  }
+  async updateQueryIds(options) {
+    const changes = [];
+    if (!options?.force) {
+      try {
+        const content = readFileSync(CACHE_PATH, "utf-8");
+        const data = JSON.parse(content);
+        const age = Date.now() - (data.timestamp || 0);
+        if (age < CACHE_TTL) {
+          return { updated: 0, changes: [] };
+        }
+      } catch {}
+    }
+    const freshIds = await this.scrapeQueryIds();
+    const newCache = {};
+    for (const [op, freshId] of Object.entries(freshIds)) {
+      const oldId = this.cache[op] || BAKED_IDS[op];
+      const oldIdStr = Array.isArray(oldId) ? oldId[0] : oldId;
+      if (freshId !== oldIdStr) {
+        changes.push(`${op}: ${oldIdStr} \u2192 ${freshId}`);
+      }
+      if (op === "TweetDetail" || op === "SearchTimeline") {
+        const bakedFallbacks = BAKED_IDS[op];
+        if (Array.isArray(bakedFallbacks)) {
+          newCache[op] = [freshId, ...bakedFallbacks.slice(1)];
+        } else {
+          newCache[op] = freshId;
+        }
+      } else {
+        newCache[op] = freshId;
+      }
+    }
+    this.saveCache(newCache);
+    this.cache = newCache;
+    return { updated: changes.length, changes };
+  }
+}
+var BAKED_IDS, CACHE_PATH, CACHE_VERSION = "v1", CACHE_TTL, queryIdManager;
+var init_query_ids = __esm(() => {
+  BAKED_IDS = {
+    CreateTweet: "nmdAQXJDxw6-0KKF2on7eA",
+    TweetDetail: ["_NvJCnIjOW__EP5-RF197A", "97JF30KziU00483E_8elBA", "aFvUsJm2c-oDkJV75blV6g"],
+    SearchTimeline: ["6AAys3t42mosm_yTI_QENg", "M1jEez78PEfVfbQLvlWMvQ", "5h0kNbk3ii97rmfY6CdgAA"],
+    UserByScreenName: ["xc8f1g7BYqr6VTzTbvNlGw", "qW5u-DAuXpMEG0zA1F7UGQ", "sLVLhk0bGj3MVFEKTdax1w"],
+    UserTweets: "Wms1GvIiHXAPBaCr9KblaA",
+    AboutAccountQuery: ["zs_jFPFT78rBpXv9Z3U2YQ", "cY6EpQYqLfc7LGIJCevPqA"],
+    MentionsTimeline: "Wms1GvIiHXAPBaCr9KblaA"
+  };
+  CACHE_PATH = join(homedir(), ".config", "twitter-client", "query-ids.json");
+  CACHE_TTL = 24 * 60 * 60 * 1000;
+  queryIdManager = new QueryIdManager;
+});
+
+// src/client/parsers.ts
+var exports_parsers = {};
+__export(exports_parsers, {
+  parseUser: () => parseUser,
+  parseTweet: () => parseTweet,
+  extractTweetsFromInstructions: () => extractTweetsFromInstructions
+});
+function parseTweet(tweetData) {
+  if (!tweetData)
+    return null;
+  const legacy = tweetData.legacy || tweetData;
+  const core = tweetData.core?.user_results?.result;
+  const userLegacy = core?.legacy;
+  const userCore = core?.core;
+  if (!legacy)
+    return null;
+  const username = userLegacy?.screen_name || userCore?.screen_name || "";
+  const name = userLegacy?.name || userCore?.name || username;
+  if (!username) {
+    return null;
+  }
+  const id = legacy.id_str || legacy.rest_id || tweetData.rest_id || "";
+  const tweet = {
+    id,
+    url: `https://x.com/${username}/status/${id}`,
+    text: legacy.full_text || legacy.text || "",
+    author: {
+      id: core?.rest_id || userLegacy?.id_str || "",
+      username,
+      name
+    },
+    createdAt: legacy.created_at || "",
+    replyCount: legacy.reply_count || 0,
+    retweetCount: legacy.retweet_count || 0,
+    likeCount: legacy.favorite_count || 0,
+    viewCount: tweetData.views?.count ? parseInt(tweetData.views.count, 10) : undefined,
+    bookmarkCount: legacy.bookmark_count
+  };
+  if (legacy.conversation_id_str) {
+    tweet.conversationId = legacy.conversation_id_str;
+  }
+  if (legacy.in_reply_to_status_id_str) {
+    tweet.inReplyToStatusId = legacy.in_reply_to_status_id_str;
+  }
+  if (legacy.extended_entities?.media) {
+    tweet.media = legacy.extended_entities.media.map((m) => {
+      const type = m.type === "video" || m.type === "animated_gif" ? m.type === "animated_gif" ? "gif" : "video" : "photo";
+      const mediaItem = {
+        type,
+        url: m.media_url_https || "",
+        altText: m.alt_text
+      };
+      const sizes = m.sizes;
+      if (sizes?.large) {
+        mediaItem.width = sizes.large.w;
+        mediaItem.height = sizes.large.h;
+      } else if (sizes?.medium) {
+        mediaItem.width = sizes.medium.w;
+        mediaItem.height = sizes.medium.h;
+      }
+      if (sizes?.small) {
+        mediaItem.previewUrl = `${m.media_url_https}:small`;
+      }
+      if ((type === "video" || type === "gif") && m.video_info?.variants) {
+        const mp4Variants = m.video_info.variants.filter((v) => v.content_type === "video/mp4" && typeof v.url === "string");
+        const mp4WithBitrate = mp4Variants.filter((v) => typeof v.bitrate === "number").sort((a, b) => b.bitrate - a.bitrate);
+        const selectedVariant = mp4WithBitrate[0] ?? mp4Variants[0];
+        if (selectedVariant) {
+          mediaItem.videoUrl = selectedVariant.url;
+        }
+        if (typeof m.video_info.duration_millis === "number") {
+          mediaItem.durationMs = m.video_info.duration_millis;
+        }
+      }
+      return mediaItem;
+    });
+  }
+  if (legacy.quoted_status_result?.result) {
+    const quoted = parseTweet(legacy.quoted_status_result.result);
+    if (quoted)
+      tweet.quotedTweet = quoted;
+  }
+  return tweet;
+}
+function parseUser(userData) {
+  if (!userData)
+    return null;
+  const legacy = userData.legacy || userData;
+  const user = {
+    id: userData.rest_id || legacy.id_str || "",
+    username: legacy.screen_name || "",
+    name: legacy.name || "",
+    description: legacy.description,
+    followersCount: legacy.followers_count,
+    followingCount: legacy.friends_count,
+    isBlueVerified: legacy.verified || legacy.is_blue_verified,
+    profileImageUrl: legacy.profile_image_url_https,
+    createdAt: legacy.created_at
+  };
+  return user;
+}
+function extractTweetsFromInstructions(instructions) {
+  const tweets = [];
+  const seenIds = new Set;
+  for (const instruction of instructions) {
+    if (!instruction)
+      continue;
+    const entries = instruction.entries || instruction.moduleItems || [];
+    for (const entry of entries) {
+      if (!entry)
+        continue;
+      const content = entry.content || entry.item?.content;
+      if (!content)
+        continue;
+      const tweetData = content.tweet_results?.result || content.tweet?.tweet_results?.result || content.itemContent?.tweet_results?.result;
+      if (tweetData) {
+        const tweet = parseTweet(tweetData);
+        if (tweet && !seenIds.has(tweet.id)) {
+          tweets.push(tweet);
+          seenIds.add(tweet.id);
+        }
+      }
+    }
+  }
+  return tweets;
+}
+
+// src/client/graphql.ts
+init_query_ids();
+import { randomUUID, randomBytes } from "crypto";
+
+class GraphQLClient {
+  authToken;
+  ct0;
+  userAgent;
+  timeout;
+  clientUuid;
+  clientDeviceId;
+  constructor(options) {
+    this.authToken = options.authToken;
+    this.ct0 = options.ct0;
+    this.timeout = options.timeout;
+    this.userAgent = options.userAgent || "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+    this.clientUuid = randomUUID();
+    this.clientDeviceId = randomUUID();
+  }
+  createTransactionId() {
+    return randomBytes(16).toString("hex");
+  }
+  getHeaders() {
+    return {
+      accept: "*/*",
+      "accept-language": "en-US,en;q=0.9",
+      authorization: "Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA",
+      "content-type": "application/json",
+      "x-csrf-token": this.ct0,
+      "x-twitter-auth-type": "OAuth2Session",
+      "x-twitter-active-user": "yes",
+      "x-twitter-client-language": "en",
+      "x-client-uuid": this.clientUuid,
+      "x-twitter-client-deviceid": this.clientDeviceId,
+      "x-client-transaction-id": this.createTransactionId(),
+      cookie: `auth_token=${this.authToken}; ct0=${this.ct0}`,
+      "user-agent": this.userAgent,
+      origin: "https://x.com",
+      referer: "https://x.com/"
+    };
+  }
+  async fetchWithTimeout(url, init) {
+    if (!this.timeout || this.timeout <= 0) {
+      return fetch(url, init);
+    }
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  getErrorCode(status, errors) {
+    if (status === 401 || status === 403) {
+      return "AUTH_FAILED";
+    }
+    if (status === 429) {
+      return "RATE_LIMITED";
+    }
+    if (status === 404) {
+      return "STALE_QUERY_ID";
+    }
+    if (errors?.some((e) => e.code === 226)) {
+      return "RATE_LIMITED";
+    }
+    return "NETWORK_ERROR";
+  }
+  async validateResponse(response) {
+    const data = await response.json();
+    if (data.errors && data.errors.length > 0) {
+      return {
+        success: false,
+        error: data.errors.map((e) => e.message).join(", "),
+        code: this.getErrorCode(500, data.errors)
+      };
+    }
+    if (!data.data) {
+      return {
+        success: false,
+        error: "No data returned from API",
+        code: "NETWORK_ERROR"
+      };
+    }
+    return {
+      success: true,
+      data: data.data
+    };
+  }
+  async request(operation, variables, features) {
+    let queryId = queryIdManager.getQueryId(operation);
+    let queryIds = Array.isArray(queryId) ? queryId : [queryId];
+    let hasRefreshed = false;
+    for (let i = 0;i < queryIds.length; i++) {
+      const id = queryIds[i];
+      const url = `https://x.com/i/api/graphql/${id}/${operation}`;
+      try {
+        const body = JSON.stringify({
+          variables,
+          features,
+          queryId: id
+        });
+        const response = await this.fetchWithTimeout(url, {
+          method: "POST",
+          headers: this.getHeaders(),
+          body
+        });
+        if (!response.ok) {
+          const code = this.getErrorCode(response.status);
+          if (response.status === 404 && i < queryIds.length - 1) {
+            continue;
+          }
+          if (response.status === 404 && i === queryIds.length - 1 && !hasRefreshed) {
+            console.info(`Query ID stale for ${operation}, refreshing...`);
+            hasRefreshed = true;
+            try {
+              await queryIdManager.updateQueryIds({ force: true });
+              queryId = queryIdManager.getQueryId(operation);
+              queryIds = Array.isArray(queryId) ? queryId : [queryId];
+              i = -1;
+              continue;
+            } catch (refreshError) {
+              return {
+                success: false,
+                error: `Failed to refresh query IDs: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`,
+                code: "NETWORK_ERROR"
+              };
+            }
+          }
+          const text = await response.text();
+          return {
+            success: false,
+            error: `HTTP ${response.status}: ${text.slice(0, 200)}`,
+            code
+          };
+        }
+        return await this.validateResponse(response);
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          return {
+            success: false,
+            error: "Request timeout",
+            code: "NETWORK_ERROR"
+          };
+        }
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error",
+          code: "NETWORK_ERROR"
+        };
+      }
+    }
+    return {
+      success: false,
+      error: "All query IDs failed",
+      code: "STALE_QUERY_ID"
+    };
+  }
+  async getCurrentUser() {
+    return await this.request("AboutAccountQuery", {}, {
+      hidden_profile_subscriptions_enabled: true,
+      hidden_profile_likes_enabled: true,
+      responsive_web_graphql_exclude_directive_enabled: true,
+      verified_phone_label_enabled: false,
+      responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+      responsive_web_graphql_timeline_navigation_enabled: true,
+      responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+      responsive_web_grok_analyze_post_followups_enabled: false,
+      responsive_web_grok_annotations_enabled: false,
+      responsive_web_grok_show_grok_translated_post: false,
+      responsive_web_jetfuel_frame: true,
+      longform_notetweets_consumption_enabled: true,
+      responsive_web_twitter_article_tweet_consumption_enabled: true,
+      tweet_awards_web_tipping_enabled: false,
+      responsive_web_media_download_video_enabled: false,
+      c9s_tweet_anatomy_moderator_badge_enabled: true
+    });
+  }
+}
+
+// src/client/rest.ts
+class RestClient {
+  authToken;
+  ct0;
+  userAgent;
+  timeout;
+  constructor(authToken, ct0, userAgent, timeout) {
+    this.authToken = authToken;
+    this.ct0 = ct0;
+    this.userAgent = userAgent;
+    this.timeout = timeout;
+  }
+  async fetchWithTimeout(url, init) {
+    if (!this.timeout || this.timeout <= 0) {
+      return fetch(url, init);
+    }
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      return await fetch(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  getHeaders() {
+    return {
+      accept: "*/*",
+      "accept-language": "en-US,en;q=0.9",
+      authorization: "Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA",
+      "content-type": "application/json",
+      "x-csrf-token": this.ct0,
+      "x-twitter-auth-type": "OAuth2Session",
+      "x-twitter-active-user": "yes",
+      "x-twitter-client-language": "en",
+      cookie: `auth_token=${this.authToken}; ct0=${this.ct0}`,
+      "user-agent": this.userAgent,
+      origin: "https://x.com",
+      referer: "https://x.com/"
+    };
+  }
+}
+
+// src/client/TwitterClient.ts
+init_query_ids();
+
+class TwitterClient {
+  graphql;
+  rest;
+  constructor(options) {
+    this.graphql = new GraphQLClient({
+      authToken: options.authToken,
+      ct0: options.ct0,
+      timeout: options.timeout
+    });
+    this.rest = new RestClient(options.authToken, options.ct0, "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36", options.timeout);
+  }
+  async whoami() {
+    const result = await this.graphql.getCurrentUser();
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        code: result.code
+      };
+    }
+    const userData = result.data;
+    if (!userData) {
+      return {
+        success: false,
+        error: "Could not extract user data from GraphQL response",
+        code: "NETWORK_ERROR"
+      };
+    }
+    const { parseUser: parseUser2 } = await Promise.resolve().then(() => exports_parsers);
+    const user = parseUser2(userData);
+    if (!user) {
+      return {
+        success: false,
+        error: "Could not parse user data",
+        code: "NETWORK_ERROR"
+      };
+    }
+    return {
+      success: true,
+      user
+    };
+  }
+  async search(query, count = 20, product = "Top") {
+    if (count < 1 || count > 200) {
+      return {
+        success: false,
+        error: "count must be between 1 and 200",
+        code: "INVALID_INPUT"
+      };
+    }
+    const features = {
+      rweb_video_screen_enabled: true,
+      profile_label_improvements_pcf_label_in_post_enabled: true,
+      responsive_web_profile_redirect_enabled: true,
+      rweb_tipjar_consumption_enabled: true,
+      verified_phone_label_enabled: false,
+      creator_subscriptions_tweet_preview_api_enabled: true,
+      responsive_web_graphql_timeline_navigation_enabled: true,
+      responsive_web_graphql_exclude_directive_enabled: true,
+      responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+      premium_content_api_read_enabled: false,
+      communities_web_enable_tweet_community_results_fetch: true,
+      c9s_tweet_anatomy_moderator_badge_enabled: true,
+      responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+      responsive_web_grok_analyze_post_followups_enabled: false,
+      responsive_web_grok_annotations_enabled: false,
+      responsive_web_jetfuel_frame: true,
+      post_ctas_fetch_enabled: true,
+      responsive_web_grok_share_attachment_enabled: true,
+      responsive_web_edit_tweet_api_enabled: true,
+      graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+      view_counts_everywhere_api_enabled: true,
+      longform_notetweets_consumption_enabled: true,
+      responsive_web_twitter_article_tweet_consumption_enabled: true,
+      tweet_awards_web_tipping_enabled: false,
+      responsive_web_grok_show_grok_translated_post: false,
+      responsive_web_grok_analysis_button_from_backend: true,
+      creator_subscriptions_quote_tweet_preview_enabled: false,
+      freedom_of_speech_not_reach_fetch_enabled: true,
+      standardized_nudges_misinfo: true,
+      tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+      rweb_video_timestamps_enabled: true,
+      longform_notetweets_rich_text_read_enabled: true,
+      longform_notetweets_inline_media_enabled: true,
+      responsive_web_grok_image_annotation_enabled: true,
+      responsive_web_grok_imagine_annotation_enabled: true,
+      responsive_web_grok_community_note_auto_translation_is_enabled: false,
+      articles_preview_enabled: true,
+      responsive_web_enhance_cards_enabled: false
+    };
+    const result = await this.graphql.request("SearchTimeline", {
+      rawQuery: query,
+      count: Math.min(count, 20),
+      querySource: "typed_query",
+      product
+    }, features);
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        code: result.code
+      };
+    }
+    const { parseTweet: parseTweet2, extractTweetsFromInstructions: extractTweetsFromInstructions2 } = await Promise.resolve().then(() => exports_parsers);
+    const instructions = result.data.search_by_raw_query?.search_timeline?.timeline?.instructions || [];
+    const tweets = extractTweetsFromInstructions2(instructions);
+    return {
+      success: true,
+      tweets: tweets.slice(0, count)
+    };
+  }
+  async getTweet(tweetIdOrUrl) {
+    let tweetId = tweetIdOrUrl;
+    const urlMatch = tweetIdOrUrl.match(/status\/(\d+)/);
+    if (urlMatch) {
+      tweetId = urlMatch[1];
+    }
+    const result = await this.graphql.request("TweetDetail", {
+      focalTweetId: tweetId,
+      with_rux_injections: false,
+      includePromotedContent: false,
+      withCommunity: true,
+      withQuickPromoteEligibilityTweetFields: true,
+      withBirdwatchNotes: true,
+      withVoice: true,
+      withV2Timeline: true
+    });
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        code: result.code
+      };
+    }
+    const { parseTweet: parseTweet2 } = await Promise.resolve().then(() => exports_parsers);
+    const tweetData = result.data.tweet_results?.result;
+    const tweet = parseTweet2(tweetData);
+    if (!tweet) {
+      return {
+        success: false,
+        error: "Could not parse tweet",
+        code: "NETWORK_ERROR"
+      };
+    }
+    return {
+      success: true,
+      tweet
+    };
+  }
+  async getThread(tweetIdOrUrl) {
+    const tweetResult = await this.getTweet(tweetIdOrUrl);
+    if (!tweetResult.success) {
+      return tweetResult;
+    }
+    return {
+      success: true,
+      tweets: [tweetResult.tweet]
+    };
+  }
+  async getUserTweets(username, count = 20, cursor) {
+    if (count < 1 || count > 200) {
+      return {
+        success: false,
+        error: "count must be between 1 and 200",
+        code: "INVALID_INPUT"
+      };
+    }
+    const queryId = queryIdManager.getQueryId("UserByScreenName");
+    const ids = Array.isArray(queryId) ? queryId : [queryId];
+    let userId;
+    for (const id of ids) {
+      try {
+        const variables = {
+          screen_name: username,
+          withSafetyModeUserFields: true
+        };
+        const features = {
+          hidden_profile_subscriptions_enabled: true,
+          hidden_profile_likes_enabled: true,
+          responsive_web_graphql_exclude_directive_enabled: true,
+          verified_phone_label_enabled: false
+        };
+        const fieldToggles = {
+          withAuxiliaryUserLabels: false
+        };
+        const params = new URLSearchParams({
+          variables: JSON.stringify(variables),
+          features: JSON.stringify(features),
+          fieldToggles: JSON.stringify(fieldToggles)
+        });
+        const url = `https://x.com/i/api/graphql/${id}/UserByScreenName?${params.toString()}`;
+        const response = await this.graphql.fetchWithTimeout(url, {
+          method: "GET",
+          headers: this.graphql.getHeaders()
+        });
+        if (!response.ok) {
+          if (response.status === 404) {
+            continue;
+          }
+          return {
+            success: false,
+            error: `HTTP ${response.status}: User lookup failed`,
+            code: "NETWORK_ERROR"
+          };
+        }
+        const data = await response.json();
+        if (data.data?.user?.result?.__typename === "UserUnavailable") {
+          return {
+            success: false,
+            error: `User @${username} not found`,
+            code: "NETWORK_ERROR"
+          };
+        }
+        userId = data.data?.user?.result?.rest_id;
+        if (userId)
+          break;
+      } catch {
+        continue;
+      }
+    }
+    if (!userId) {
+      return {
+        success: false,
+        error: "Failed to resolve user ID",
+        code: "NETWORK_ERROR"
+      };
+    }
+    const tweetsResult = await this.graphql.request("UserTweets", {
+      userId,
+      count: Math.min(count, 40),
+      cursor,
+      includePromotedContent: false,
+      withClientEventToken: false,
+      withBirdwatchNotes: false,
+      withVoice: true,
+      withV2Timeline: true
+    });
+    if (!tweetsResult.success) {
+      return {
+        success: false,
+        error: tweetsResult.error,
+        code: tweetsResult.code
+      };
+    }
+    const { extractTweetsFromInstructions: extractTweetsFromInstructions2 } = await Promise.resolve().then(() => exports_parsers);
+    const instructions = tweetsResult.data.user?.result?.timeline_response?.timeline?.instructions || [];
+    const tweets = extractTweetsFromInstructions2(instructions);
+    return {
+      success: true,
+      tweets: tweets.slice(0, count)
+    };
+  }
+  async tweet(text) {
+    if (!text || text.trim().length === 0) {
+      return {
+        success: false,
+        error: "Tweet text cannot be empty",
+        code: "INVALID_INPUT"
+      };
+    }
+    if (text.length > 280) {
+      return {
+        success: false,
+        error: "Tweet text cannot exceed 280 characters",
+        code: "INVALID_INPUT"
+      };
+    }
+    const result = await this.graphql.request("CreateTweet", {
+      tweet_text: text,
+      dark_request: false,
+      media: {
+        media_entities: [],
+        possibly_sensitive: false
+      },
+      semantic_annotation_ids: []
+    }, {
+      rweb_video_screen_enabled: true,
+      responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+      responsive_web_grok_analyze_post_followups_enabled: false,
+      responsive_web_grok_annotations_enabled: false,
+      responsive_web_grok_show_grok_translated_post: false,
+      responsive_web_jetfuel_frame: true,
+      longform_notetweets_consumption_enabled: true,
+      responsive_web_twitter_article_tweet_consumption_enabled: true,
+      tweet_awards_web_tipping_enabled: false,
+      responsive_graphql_exclude_directive_enabled: true,
+      responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+      responsive_web_graphql_timeline_navigation_enabled: true,
+      c9s_tweet_anatomy_moderator_badge_enabled: true,
+      verified_phone_label_enabled: false,
+      responsive_web_media_download_video_enabled: false
+    });
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        code: result.code
+      };
+    }
+    const tweetId = result.data.create_tweet?.tweet_results?.result?.rest_id;
+    if (!tweetId) {
+      return {
+        success: false,
+        error: "Could not parse tweet ID from response",
+        code: "NETWORK_ERROR"
+      };
+    }
+    return {
+      success: true,
+      tweetId
+    };
+  }
+  async reply(tweetId, text) {
+    if (!text || text.trim().length === 0) {
+      return {
+        success: false,
+        error: "Reply text cannot be empty",
+        code: "INVALID_INPUT"
+      };
+    }
+    if (text.length > 280) {
+      return {
+        success: false,
+        error: "Reply text cannot exceed 280 characters",
+        code: "INVALID_INPUT"
+      };
+    }
+    const result = await this.graphql.request("CreateTweet", {
+      tweet_text: text,
+      media: {
+        media_entities: [],
+        tagged_users: []
+      },
+      semantic_annotation_ids: [],
+      reply_settings: {
+        in_reply_to_tweet_id: tweetId
+      }
+    });
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        code: result.code
+      };
+    }
+    const newTweetId = result.data.create_tweet?.tweet_results?.result?.rest_id;
+    if (!newTweetId) {
+      return {
+        success: false,
+        error: "Could not parse tweet ID from response",
+        code: "NETWORK_ERROR"
+      };
+    }
+    return {
+      success: true,
+      tweetId: newTweetId
+    };
+  }
+  async getNews(count = 20) {
+    if (count < 1 || count > 200) {
+      return {
+        success: false,
+        error: "count must be between 1 and 200",
+        code: "INVALID_INPUT"
+      };
+    }
+    const result = await this.graphql.request("NewsForYou", {
+      count: Math.min(count, 40),
+      includePromotedContent: false,
+      latestControlAvailable: true,
+      requestContext: "launch",
+      withClientEventToken: false,
+      withBirdwatchNotes: false,
+      withVoice: true,
+      withV2Timeline: true
+    });
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        code: result.code
+      };
+    }
+    const { extractTweetsFromInstructions: extractTweetsFromInstructions2 } = await Promise.resolve().then(() => exports_parsers);
+    const instructions = result.data.home?.home_timeline_urt?.instructions || [];
+    const tweets = extractTweetsFromInstructions2(instructions);
+    const items = tweets.slice(0, count).map((tweet) => ({
+      id: tweet.id,
+      headline: tweet.text,
+      tweets: [tweet]
+    }));
+    return {
+      success: true,
+      items
+    };
+  }
+  async getMentions(count = 20) {
+    if (count < 1 || count > 200) {
+      return {
+        success: false,
+        error: "count must be between 1 and 200",
+        code: "INVALID_INPUT"
+      };
+    }
+    const result = await this.graphql.request("MentionsTimeline", {
+      count: Math.min(count, 40),
+      includePromotedContent: false,
+      latestControlAvailable: true,
+      requestContext: "launch",
+      withClientEventToken: false,
+      withBirdwatchNotes: false,
+      withVoice: true,
+      withV2Timeline: true
+    });
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        code: result.code
+      };
+    }
+    const { extractTweetsFromInstructions: extractTweetsFromInstructions2 } = await Promise.resolve().then(() => exports_parsers);
+    const instructions = result.data.home?.home_timeline_urt?.instructions || [];
+    const tweets = extractTweetsFromInstructions2(instructions);
+    return {
+      success: true,
+      tweets: tweets.slice(0, count)
+    };
+  }
+}
+// src/cli.ts
+var AUTH_TOKEN = process.env.TWITTER_AUTH_TOKEN || "";
+var CT0 = process.env.TWITTER_CT0 || "";
+if (!AUTH_TOKEN || !CT0) {
+  console.error("Error: TWITTER_AUTH_TOKEN and TWITTER_CT0 environment variables must be set");
+  process.exit(1);
+}
+var client = new TwitterClient({
+  authToken: AUTH_TOKEN,
+  ct0: CT0
+});
+var args = process.argv.slice(2);
+var command = args[0];
+async function main() {
+  switch (command) {
+    case "whoami": {
+      const result = await client.whoami();
+      if (!result.success) {
+        console.error(`Error: ${result.error}`);
+        if (result.code === "AUTH_FAILED") {
+          console.error(`
+Authentication failed. Please set these environment variables:`);
+          console.error('  export TWITTER_AUTH_TOKEN="your_auth_token"');
+          console.error('  export TWITTER_CT0="your_ct0_token"');
+          console.error(`
+Get credentials from browser DevTools \u2192 Application \u2192 Cookies \u2192 twitter.com`);
+        } else if (result.code === "STALE_QUERY_ID") {
+          console.error(`
+Query ID may be stale. Try updating:`);
+          console.error("  bird update-query-ids");
+        }
+        process.exit(1);
+      }
+      console.log(`Logged in as: @${result.user.username} (${result.user.name})`);
+      console.log(`User ID: ${result.user.id}`);
+      if (result.user.followersCount !== undefined) {
+        console.log(`Followers: ${result.user.followersCount.toLocaleString()}`);
+      }
+      if (result.user.followingCount !== undefined) {
+        console.log(`Following: ${result.user.followingCount.toLocaleString()}`);
+      }
+      break;
+    }
+    case "search": {
+      const latestFlag = args.includes("--latest");
+      const filteredArgs = args.filter((arg) => arg !== "--latest");
+      const query = filteredArgs[1];
+      if (!query) {
+        console.error("Usage: bun run src/cli.ts search [--latest] <query>");
+        process.exit(1);
+      }
+      const result = await client.search(query, 20, latestFlag ? "Latest" : "Top");
+      if (result.success) {
+        result.tweets.forEach((tweet) => {
+          console.log(`@${tweet.author.username}: ${tweet.text}`);
+          console.log(`Likes: ${tweet.likeCount} Retweets: ${tweet.retweetCount}
+`);
+        });
+      } else {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "tweet": {
+      const text = args.slice(1).join(" ");
+      if (!text) {
+        console.error("Usage: bun run src/cli.ts tweet <text>");
+        process.exit(1);
+      }
+      const result = await client.tweet(text);
+      if (result.success) {
+        console.log(`Tweet posted! ID: ${result.tweetId}`);
+        console.log(`https://x.com/user/status/${result.tweetId}`);
+      } else {
+        if (result.error?.includes("226") || result.error?.includes("automated")) {
+          console.error('\u2717 Tweet rejected by Twitter: "Looks automated"');
+          console.error("");
+          console.error("This usually means:");
+          console.error("  \u2022 Account is new or has low activity");
+          console.error("  \u2022 Tweets need more variation/personal touch");
+          console.error("  \u2022 Try posting from the web interface first");
+        } else {
+          console.error(`\u2717 Error: ${result.error}`);
+        }
+        process.exit(1);
+      }
+      break;
+    }
+    case "get": {
+      const tweetId = args[1];
+      if (!tweetId) {
+        console.error("Usage: bun run src/cli.ts get <tweet_id_or_url>");
+        process.exit(1);
+      }
+      const result = await client.getTweet(tweetId);
+      if (result.success) {
+        const tweet = result.tweet;
+        console.log(`@${tweet.author.username} (@${tweet.author.name})`);
+        console.log(`${tweet.text}`);
+        console.log(`
+Likes: ${tweet.likeCount} Retweets: ${tweet.retweetCount} Replies: ${tweet.replyCount}`);
+        console.log(`https://x.com/${tweet.author.username}/status/${tweet.id}`);
+      } else {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "user": {
+      const username = args[1];
+      if (!username) {
+        console.error("Usage: bun run src/cli.ts user <username>");
+        process.exit(1);
+      }
+      const result = await client.getUserTweets(username);
+      if (result.success) {
+        result.tweets.forEach((tweet) => {
+          console.log(`@${tweet.author.username}: ${tweet.text}`);
+          console.log(`Likes: ${tweet.likeCount} Retweets: ${tweet.retweetCount}
+`);
+        });
+      } else {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "news": {
+      const result = await client.getNews();
+      if (result.success) {
+        result.items.forEach((item, i) => {
+          console.log(`${i + 1}. ${item.headline}`);
+          if (item.tweets && item.tweets[0]) {
+            console.log(`   @${item.tweets[0].author.username}
+`);
+          }
+        });
+      } else {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "mentions": {
+      const result = await client.getMentions();
+      if (result.success) {
+        result.tweets.forEach((tweet) => {
+          console.log(`@${tweet.author.username}: ${tweet.text}`);
+          console.log(`Likes: ${tweet.likeCount} Retweets: ${tweet.retweetCount}
+`);
+        });
+      } else {
+        console.error(`Error: ${result.error}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "update-query-ids": {
+      const { QueryIdManager: QueryIdManager2 } = await Promise.resolve().then(() => (init_query_ids(), exports_query_ids));
+      const manager = new QueryIdManager2;
+      const result = await manager.updateQueryIds({ force: args.includes("--fresh") });
+      if (result.updated === 0) {
+        console.log("Query IDs are up to date (cache is fresh).");
+      } else {
+        console.log(`\u2713 Updated ${result.updated} query ID(s):`);
+        result.changes.forEach((change) => {
+          console.log(`  ${change}`);
+        });
+      }
+      break;
+    }
+    default:
+      console.log("Twitter Client CLI");
+      console.log(`
+Commands:`);
+      console.log("  whoami                    - Show current user info");
+      console.log("  search [--latest] <query>   - Search for tweets (default: top, use --latest for recent)");
+      console.log("  tweet <text>              - Post a tweet");
+      console.log("  get <tweet_id>            - Get a tweet by ID or URL");
+      console.log("  user <username>           - Get tweets from a user");
+      console.log("  news                      - Get news timeline");
+      console.log("  mentions                  - Get mentions timeline");
+      console.log("  update-query-ids [--fresh] - Update query IDs from Twitter");
+      console.log(`
+Flags:`);
+      console.log("  --fresh                   - Force refresh even if cache is fresh");
+      break;
+  }
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});