@cm-growth-hacking/twitter-client 0.2.0

package/dist/client/graphql.js

@@ -0,0 +1,191 @@
+import { randomUUID, randomBytes } from 'node:crypto';
+import { queryIdManager } from './query-ids.js';
+export 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; // Track if we've already attempted refresh
+        // Try each query ID in order
+        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);
+                    // Auto-refresh on 404 (except for last query ID)
+                    if (response.status === 404 && i < queryIds.length - 1) {
+                        continue; // Try next fallback ID
+                    }
+                    // If 404 and we have no more fallbacks, try refreshing once (but only once per request)
+                    if (response.status === 404 && i === queryIds.length - 1 && !hasRefreshed) {
+                        console.info(`Query ID stale for ${operation}, refreshing...`);
+                        hasRefreshed = true; // Mark that we've attempted refresh
+                        try {
+                            await queryIdManager.updateQueryIds({ force: true });
+                            // Get fresh query IDs and continue the loop with them
+                            queryId = queryIdManager.getQueryId(operation);
+                            queryIds = Array.isArray(queryId) ? queryId : [queryId];
+                            // Reset index to try fresh IDs from the beginning
+                            i = -1;
+                            continue;
+                        }
+                        catch (refreshError) {
+                            return {
+                                success: false,
+                                error: `Failed to refresh query IDs: ${refreshError instanceof Error ? refreshError.message : 'Unknown error'}`,
+                                code: 'NETWORK_ERROR',
+                            };
+                        }
+                    }
+                    // For other errors or if we've already refreshed, return 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',
+        };
+    }
+    /**
+     * Fetch the authenticated user's information using GraphQL
+     */
+    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,
+        });
+    }
+}

package/dist/client/parsers.d.ts

@@ -0,0 +1,14 @@
+import type { Tweet, User } from './types.js';
+/**
+ * Parse tweet object from GraphQL response
+ */
+export declare function parseTweet(tweetData: any): Tweet | null;
+/**
+ * Parse user object from GraphQL response
+ */
+export declare function parseUser(userData: any): User | null;
+/**
+ * Extract tweets from timeline instructions
+ */
+export declare function extractTweetsFromInstructions(instructions: any[]): Tweet[];
+//# sourceMappingURL=parsers.d.ts.map

package/dist/client/parsers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers.d.ts","sourceRoot":"","sources":["../../src/client/parsers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAa,MAAM,YAAY,CAAC;AAEzD;;GAEG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,GAAG,GAAG,KAAK,GAAG,IAAI,CAoGvD;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI,CAkBpD;AAED;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,YAAY,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,CAoC1E"}

package/dist/client/parsers.js

@@ -0,0 +1,147 @@
+/**
+ * Parse tweet object from GraphQL response
+ */
+export 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;
+    // Extract username from either legacy or core (Twitter uses different locations)
+    const username = userLegacy?.screen_name || userCore?.screen_name || '';
+    const name = userLegacy?.name || userCore?.name || username;
+    if (!username) {
+        // Skip tweets without identifiable author
+        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,
+    };
+    // Optional fields
+    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;
+    }
+    // Parse media with enhanced fields (width, height, preview, video info)
+    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,
+            };
+            // Add dimensions from largest available size
+            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;
+            }
+            // Add thumbnail/preview URL
+            if (sizes?.small) {
+                mediaItem.previewUrl = `${m.media_url_https}:small`;
+            }
+            // Extract video URL and duration for videos/gifs
+            if ((type === 'video' || type === 'gif') && m.video_info?.variants) {
+                // Prefer highest bitrate MP4, fall back to first MP4
+                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;
+                }
+                // Add video duration
+                if (typeof m.video_info.duration_millis === 'number') {
+                    mediaItem.durationMs = m.video_info.duration_millis;
+                }
+            }
+            return mediaItem;
+        });
+    }
+    // Parse quoted tweet
+    if (legacy.quoted_status_result?.result) {
+        const quoted = parseTweet(legacy.quoted_status_result.result);
+        if (quoted)
+            tweet.quotedTweet = quoted;
+    }
+    return tweet;
+}
+/**
+ * Parse user object from GraphQL response
+ */
+export 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;
+}
+/**
+ * Extract tweets from timeline instructions
+ */
+export function extractTweetsFromInstructions(instructions) {
+    const tweets = [];
+    const seenIds = new Set();
+    for (const instruction of instructions) {
+        if (!instruction)
+            continue;
+        // Handle different instruction types
+        const entries = instruction.entries ||
+            instruction.moduleItems ||
+            [];
+        for (const entry of entries) {
+            if (!entry)
+                continue;
+            const content = entry.content || entry.item?.content;
+            if (!content)
+                continue;
+            // Try to find tweet data in various possible locations
+            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;
+}

package/dist/client/query-ids.d.ts

@@ -0,0 +1,22 @@
+export declare class QueryIdManager {
+    private cache;
+    constructor();
+    private loadCache;
+    private saveCache;
+    getQueryId(operation: string): string | string[];
+    /**
+     * Fetch fresh query IDs from Twitter's web client bundle
+     */
+    scrapeQueryIds(): Promise<Record<string, string>>;
+    /**
+     * Update query IDs by scraping Twitter's web client
+     */
+    updateQueryIds(options?: {
+        force?: boolean;
+    }): Promise<{
+        updated: number;
+        changes: string[];
+    }>;
+}
+export declare const queryIdManager: QueryIdManager;
+//# sourceMappingURL=query-ids.d.ts.map

package/dist/client/query-ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-ids.d.ts","sourceRoot":"","sources":["../../src/client/query-ids.ts"],"names":[],"mappings":"AAkBA,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAyC;;IAMtD,OAAO,CAAC,SAAS;IAoBjB,OAAO,CAAC,SAAS;IAiBjB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE;IAYhD;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IA+CvD;;OAEG;IACG,cAAc,CAAC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAkDrG;AAED,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/client/query-ids.js

@@ -0,0 +1,157 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+const 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',
+};
+const CACHE_PATH = join(homedir(), '.config', 'twitter-client', 'query-ids.json');
+const CACHE_VERSION = 'v1';
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+export class QueryIdManager {
+    cache = {};
+    constructor() {
+        this.loadCache();
+    }
+    loadCache() {
+        try {
+            const content = readFileSync(CACHE_PATH, 'utf-8');
+            const data = JSON.parse(content);
+            // Check cache version and TTL
+            if (data.version !== CACHE_VERSION) {
+                return; // Version mismatch, use baked-in
+            }
+            if (data.timestamp && Date.now() - data.timestamp > CACHE_TTL) {
+                return; // Cache expired, use baked-in
+            }
+            this.cache = data.queryIds || {};
+        }
+        catch {
+            // Cache doesn't exist or is invalid, use baked-in
+            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) {
+        // Check cache first
+        if (this.cache[operation]) {
+            return this.cache[operation];
+        }
+        // Fall back to baked-in
+        if (BAKED_IDS[operation]) {
+            return BAKED_IDS[operation];
+        }
+        throw new Error(`Unknown operation: ${operation}`);
+    }
+    /**
+     * Fetch fresh query IDs from Twitter's web client bundle
+     */
+    async scrapeQueryIds() {
+        const operations = Object.keys(BAKED_IDS);
+        const queryIds = {};
+        // Fetch Twitter's main client JS bundle
+        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();
+            // Extract query IDs using regex
+            // Pattern: operationName:"queryId"
+            for (const op of operations) {
+                // Try multiple regex patterns
+                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]; // Use first match
+                        break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Scraping failed, using baked-in IDs: ${error}`);
+            // Return baked-in IDs as fallback
+            for (const op of operations) {
+                const id = BAKED_IDS[op];
+                queryIds[op] = Array.isArray(id) ? id[0] : id;
+            }
+        }
+        return queryIds;
+    }
+    /**
+     * Update query IDs by scraping Twitter's web client
+     */
+    async updateQueryIds(options) {
+        const changes = [];
+        // Check if cache is still fresh (unless forced)
+        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 {
+                // Cache doesn't exist, proceed with update
+            }
+        }
+        // Scrape fresh IDs
+        const freshIds = await this.scrapeQueryIds();
+        // Build new cache with fresh IDs
+        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} → ${freshId}`);
+            }
+            // For operations with fallbacks, include multiple IDs
+            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;
+            }
+        }
+        // Save to cache
+        this.saveCache(newCache);
+        this.cache = newCache;
+        return { updated: changes.length, changes };
+    }
+}
+export const queryIdManager = new QueryIdManager();

package/dist/client/rest.d.ts

@@ -0,0 +1,10 @@
+export declare class RestClient {
+    private authToken;
+    private ct0;
+    private userAgent;
+    private timeout;
+    constructor(authToken: string, ct0: string, userAgent: string, timeout?: number);
+    private fetchWithTimeout;
+    private getHeaders;
+}
+//# sourceMappingURL=rest.d.ts.map

package/dist/client/rest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest.d.ts","sourceRoot":"","sources":["../../src/client/rest.ts"],"names":[],"mappings":"AAEA,qBAAa,UAAU;IAInB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,GAAG;IACX,OAAO,CAAC,SAAS;IALnB,OAAO,CAAC,OAAO,CAAqB;gBAG1B,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE,MAAM;YAKJ,gBAAgB;IAe9B,OAAO,CAAC,UAAU;CAgBnB"}

package/dist/client/rest.js

@@ -0,0 +1,41 @@
+export 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/',
+        };
+    }
+}

package/dist/client/types.d.ts

@@ -0,0 +1,80 @@
+export interface Tweet {
+    id: string;
+    url: string;
+    text: string;
+    author: {
+        username: string;
+        name: string;
+        id: string;
+    };
+    createdAt: string;
+    replyCount: number;
+    retweetCount: number;
+    likeCount: number;
+    viewCount?: number;
+    bookmarkCount?: number;
+    conversationId?: string;
+    inReplyToStatusId?: string;
+    quotedTweet?: Tweet;
+    media?: MediaItem[];
+}
+export interface MediaItem {
+    type: 'photo' | 'video' | 'gif';
+    url: string;
+    altText?: string;
+    width?: number;
+    height?: number;
+    previewUrl?: string;
+    videoUrl?: string;
+    durationMs?: number;
+}
+export interface User {
+    id: string;
+    username: string;
+    name: string;
+    description?: string;
+    followersCount?: number;
+    followingCount?: number;
+    isBlueVerified?: boolean;
+    profileImageUrl?: string;
+    createdAt?: string;
+}
+export interface NewsItem {
+    id: string;
+    headline: string;
+    category?: string;
+    timeAgo?: string;
+    postCount?: number;
+    description?: string;
+    url?: string;
+    tweets?: Tweet[];
+}
+export type SuccessResult<T> = {
+    success: true;
+} & T;
+export type ErrorResult = {
+    success: false;
+    error: string;
+    code?: ErrorCode;
+};
+export type Result<T> = SuccessResult<T> | ErrorResult;
+export type ErrorCode = 'AUTH_FAILED' | 'RATE_LIMITED' | 'INVALID_INPUT' | 'NETWORK_ERROR' | 'STALE_QUERY_ID';
+export type TweetResult = Result<{
+    tweet: Tweet;
+}>;
+export type TweetsResult = Result<{
+    tweets: Tweet[];
+    nextCursor?: string;
+}>;
+export type PostResult = Result<{
+    tweetId: string;
+}>;
+export type UserResult = Result<{
+    user: User;
+}>;
+export type NewsResult = Result<{
+    items: NewsItem[];
+}>;
+export type SearchResult = TweetsResult;
+export type ThreadResult = TweetsResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/client/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/client/types.ts"],"names":[],"mappings":"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"}