427 lines
14 KiB
TypeScript
427 lines
14 KiB
TypeScript
import type { AbstractConstructor, Mixin, TwitterClientBase } from './twitter-client-base.js';
|
|
import {
|
|
SETTINGS_NAME_REGEX,
|
|
SETTINGS_SCREEN_NAME_REGEX,
|
|
SETTINGS_USER_ID_REGEX,
|
|
TWITTER_API_BASE,
|
|
} from './twitter-client-constants.js';
|
|
import { buildFollowingFeatures } from './twitter-client-features.js';
|
|
import type { CurrentUserResult, FollowingResult } from './twitter-client-types.js';
|
|
import { parseUsersFromInstructions } from './twitter-client-utils.js';
|
|
|
|
export interface TwitterClientUserMethods {
|
|
getCurrentUser(): Promise<CurrentUserResult>;
|
|
getFollowing(userId: string, count?: number): Promise<FollowingResult>;
|
|
getFollowers(userId: string, count?: number): Promise<FollowingResult>;
|
|
}
|
|
|
|
export function withUsers<TBase extends AbstractConstructor<TwitterClientBase>>(
|
|
Base: TBase,
|
|
): Mixin<TBase, TwitterClientUserMethods> {
|
|
abstract class TwitterClientUsers extends Base {
|
|
// biome-ignore lint/complexity/noUselessConstructor lint/suspicious/noExplicitAny: TS mixin constructor requirement.
|
|
constructor(...args: any[]) {
|
|
super(...args);
|
|
}
|
|
|
|
private async getFollowingQueryIds(): Promise<string[]> {
|
|
const primary = await this.getQueryId('Following');
|
|
return Array.from(new Set([primary, 'BEkNpEt5pNETESoqMsTEGA']));
|
|
}
|
|
|
|
private async getFollowersQueryIds(): Promise<string[]> {
|
|
const primary = await this.getQueryId('Followers');
|
|
return Array.from(new Set([primary, 'kuFUYP9eV1FPoEy4N-pi7w']));
|
|
}
|
|
|
|
private async getFollowersViaRest(userId: string, count: number): Promise<FollowingResult> {
|
|
const params = new URLSearchParams({
|
|
user_id: userId,
|
|
count: String(count),
|
|
skip_status: 'true',
|
|
include_user_entities: 'false',
|
|
});
|
|
|
|
const urls = [
|
|
`https://x.com/i/api/1.1/followers/list.json?${params.toString()}`,
|
|
`https://api.twitter.com/1.1/followers/list.json?${params.toString()}`,
|
|
];
|
|
|
|
let lastError: string | undefined;
|
|
|
|
for (const url of urls) {
|
|
try {
|
|
const response = await this.fetchWithTimeout(url, {
|
|
method: 'GET',
|
|
headers: this.getHeaders(),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const text = await response.text();
|
|
lastError = `HTTP ${response.status}: ${text.slice(0, 200)}`;
|
|
continue;
|
|
}
|
|
|
|
const data = (await response.json()) as {
|
|
users?: Array<{
|
|
id_str?: string;
|
|
id?: string | number;
|
|
screen_name?: string;
|
|
name?: string;
|
|
description?: string;
|
|
followers_count?: number;
|
|
friends_count?: number;
|
|
verified?: boolean;
|
|
profile_image_url_https?: string;
|
|
created_at?: string;
|
|
}>;
|
|
};
|
|
|
|
const users = (data.users ?? [])
|
|
.map((u) => {
|
|
const id = typeof u.id_str === 'string' ? u.id_str : typeof u.id === 'number' ? String(u.id) : null;
|
|
const username = typeof u.screen_name === 'string' ? u.screen_name : null;
|
|
if (!id || !username) {
|
|
return null;
|
|
}
|
|
return {
|
|
id,
|
|
username,
|
|
name: typeof u.name === 'string' && u.name.length > 0 ? u.name : username,
|
|
description: typeof u.description === 'string' ? u.description : undefined,
|
|
followersCount: typeof u.followers_count === 'number' ? u.followers_count : undefined,
|
|
followingCount: typeof u.friends_count === 'number' ? u.friends_count : undefined,
|
|
isBlueVerified: typeof u.verified === 'boolean' ? u.verified : undefined,
|
|
profileImageUrl: typeof u.profile_image_url_https === 'string' ? u.profile_image_url_https : undefined,
|
|
createdAt: typeof u.created_at === 'string' ? u.created_at : undefined,
|
|
};
|
|
})
|
|
.filter((u) => u !== null);
|
|
|
|
return { success: true, users };
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error.message : String(error);
|
|
}
|
|
}
|
|
|
|
return { success: false, error: lastError ?? 'Unknown error fetching followers' };
|
|
}
|
|
|
|
/**
|
|
* Fetch the account associated with the current cookies
|
|
*/
|
|
async getCurrentUser(): Promise<CurrentUserResult> {
|
|
const candidateUrls = [
|
|
'https://x.com/i/api/account/settings.json',
|
|
'https://api.twitter.com/1.1/account/settings.json',
|
|
'https://x.com/i/api/account/verify_credentials.json?skip_status=true&include_entities=false',
|
|
'https://api.twitter.com/1.1/account/verify_credentials.json?skip_status=true&include_entities=false',
|
|
];
|
|
|
|
let lastError: string | undefined;
|
|
|
|
for (const url of candidateUrls) {
|
|
try {
|
|
const response = await this.fetchWithTimeout(url, {
|
|
method: 'GET',
|
|
headers: this.getHeaders(),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
const text = await response.text();
|
|
lastError = `HTTP ${response.status}: ${text.slice(0, 200)}`;
|
|
continue;
|
|
}
|
|
|
|
// biome-ignore lint/suspicious/noExplicitAny: Twitter API response is dynamic here
|
|
let data: any;
|
|
try {
|
|
data = await response.json();
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error.message : String(error);
|
|
continue;
|
|
}
|
|
|
|
const username =
|
|
typeof data?.screen_name === 'string'
|
|
? data.screen_name
|
|
: typeof data?.user?.screen_name === 'string'
|
|
? data.user.screen_name
|
|
: null;
|
|
|
|
const name =
|
|
typeof data?.name === 'string'
|
|
? data.name
|
|
: typeof data?.user?.name === 'string'
|
|
? data.user.name
|
|
: (username ?? '');
|
|
|
|
const userId =
|
|
typeof data?.user_id === 'string'
|
|
? data.user_id
|
|
: typeof data?.user_id_str === 'string'
|
|
? data.user_id_str
|
|
: typeof data?.user?.id_str === 'string'
|
|
? data.user.id_str
|
|
: typeof data?.user?.id === 'string'
|
|
? data.user.id
|
|
: null;
|
|
|
|
if (username && userId) {
|
|
this.clientUserId = userId;
|
|
return {
|
|
success: true,
|
|
user: {
|
|
id: userId,
|
|
username,
|
|
name: name || username,
|
|
},
|
|
};
|
|
}
|
|
|
|
lastError = 'Could not determine current user from response';
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error.message : String(error);
|
|
}
|
|
}
|
|
|
|
// Fallback: scrape the authenticated settings page (HTML) for screen_name/user_id
|
|
const profilePages = ['https://x.com/settings/account', 'https://twitter.com/settings/account'];
|
|
for (const page of profilePages) {
|
|
try {
|
|
const response = await this.fetchWithTimeout(page, {
|
|
headers: {
|
|
cookie: this.cookieHeader,
|
|
'user-agent': this.userAgent,
|
|
},
|
|
});
|
|
|
|
if (!response.ok) {
|
|
lastError = `HTTP ${response.status} (settings page)`;
|
|
continue;
|
|
}
|
|
|
|
const html = await response.text();
|
|
const usernameMatch = SETTINGS_SCREEN_NAME_REGEX.exec(html);
|
|
const idMatch = SETTINGS_USER_ID_REGEX.exec(html);
|
|
const nameMatch = SETTINGS_NAME_REGEX.exec(html);
|
|
|
|
const username = usernameMatch?.[1];
|
|
const userId = idMatch?.[1];
|
|
const name = nameMatch?.[1]?.replace(/\\"/g, '"');
|
|
|
|
if (username && userId) {
|
|
return {
|
|
success: true,
|
|
user: {
|
|
id: userId,
|
|
username,
|
|
name: name || username,
|
|
},
|
|
};
|
|
}
|
|
|
|
lastError = 'Could not parse settings page for user info';
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error.message : String(error);
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: false,
|
|
error: lastError ?? 'Unknown error fetching current user',
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get users that a user is following
|
|
*/
|
|
async getFollowing(userId: string, count = 20): Promise<FollowingResult> {
|
|
const variables = {
|
|
userId,
|
|
count,
|
|
includePromotedContent: false,
|
|
};
|
|
|
|
const features = buildFollowingFeatures();
|
|
|
|
const params = new URLSearchParams({
|
|
variables: JSON.stringify(variables),
|
|
features: JSON.stringify(features),
|
|
});
|
|
|
|
const tryOnce = async () => {
|
|
let lastError: string | undefined;
|
|
let had404 = false;
|
|
const queryIds = await this.getFollowingQueryIds();
|
|
|
|
for (const queryId of queryIds) {
|
|
const url = `${TWITTER_API_BASE}/${queryId}/Following?${params.toString()}`;
|
|
|
|
try {
|
|
const response = await this.fetchWithTimeout(url, {
|
|
method: 'GET',
|
|
headers: this.getHeaders(),
|
|
});
|
|
|
|
if (response.status === 404) {
|
|
had404 = true;
|
|
lastError = `HTTP ${response.status}`;
|
|
continue;
|
|
}
|
|
|
|
if (!response.ok) {
|
|
const text = await response.text();
|
|
return { success: false as const, error: `HTTP ${response.status}: ${text.slice(0, 200)}`, had404 };
|
|
}
|
|
|
|
const data = (await response.json()) as {
|
|
data?: {
|
|
user?: {
|
|
result?: {
|
|
timeline?: {
|
|
timeline?: {
|
|
instructions?: Array<{ type?: string; entries?: Array<unknown> }>;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
errors?: Array<{ message: string }>;
|
|
};
|
|
|
|
if (data.errors && data.errors.length > 0) {
|
|
return { success: false as const, error: data.errors.map((e) => e.message).join(', '), had404 };
|
|
}
|
|
|
|
const instructions = data.data?.user?.result?.timeline?.timeline?.instructions;
|
|
const users = parseUsersFromInstructions(instructions);
|
|
|
|
return { success: true as const, users, had404 };
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error.message : String(error);
|
|
}
|
|
}
|
|
|
|
return { success: false as const, error: lastError ?? 'Unknown error fetching following', had404 };
|
|
};
|
|
|
|
const firstAttempt = await tryOnce();
|
|
if (firstAttempt.success) {
|
|
return { success: true, users: firstAttempt.users };
|
|
}
|
|
|
|
if (firstAttempt.had404) {
|
|
await this.refreshQueryIds();
|
|
const secondAttempt = await tryOnce();
|
|
if (secondAttempt.success) {
|
|
return { success: true, users: secondAttempt.users };
|
|
}
|
|
return { success: false, error: secondAttempt.error };
|
|
}
|
|
|
|
return { success: false, error: firstAttempt.error };
|
|
}
|
|
|
|
/**
|
|
* Get users that follow a user
|
|
*/
|
|
async getFollowers(userId: string, count = 20): Promise<FollowingResult> {
|
|
const variables = {
|
|
userId,
|
|
count,
|
|
includePromotedContent: false,
|
|
};
|
|
|
|
const features = buildFollowingFeatures();
|
|
|
|
const params = new URLSearchParams({
|
|
variables: JSON.stringify(variables),
|
|
features: JSON.stringify(features),
|
|
});
|
|
|
|
const tryOnce = async () => {
|
|
let lastError: string | undefined;
|
|
let had404 = false;
|
|
const queryIds = await this.getFollowersQueryIds();
|
|
|
|
for (const queryId of queryIds) {
|
|
const url = `${TWITTER_API_BASE}/${queryId}/Followers?${params.toString()}`;
|
|
|
|
try {
|
|
const response = await this.fetchWithTimeout(url, {
|
|
method: 'GET',
|
|
headers: this.getHeaders(),
|
|
});
|
|
|
|
if (response.status === 404) {
|
|
had404 = true;
|
|
lastError = `HTTP ${response.status}`;
|
|
continue;
|
|
}
|
|
|
|
if (!response.ok) {
|
|
const text = await response.text();
|
|
return { success: false as const, error: `HTTP ${response.status}: ${text.slice(0, 200)}`, had404 };
|
|
}
|
|
|
|
const data = (await response.json()) as {
|
|
data?: {
|
|
user?: {
|
|
result?: {
|
|
timeline?: {
|
|
timeline?: {
|
|
instructions?: Array<{ type?: string; entries?: Array<unknown> }>;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
errors?: Array<{ message: string }>;
|
|
};
|
|
|
|
if (data.errors && data.errors.length > 0) {
|
|
return { success: false as const, error: data.errors.map((e) => e.message).join(', '), had404 };
|
|
}
|
|
|
|
const instructions = data.data?.user?.result?.timeline?.timeline?.instructions;
|
|
const users = parseUsersFromInstructions(instructions);
|
|
|
|
return { success: true as const, users, had404 };
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error.message : String(error);
|
|
}
|
|
}
|
|
|
|
return { success: false as const, error: lastError ?? 'Unknown error fetching followers', had404 };
|
|
};
|
|
|
|
const firstAttempt = await tryOnce();
|
|
if (firstAttempt.success) {
|
|
return { success: true, users: firstAttempt.users };
|
|
}
|
|
|
|
if (firstAttempt.had404) {
|
|
await this.refreshQueryIds();
|
|
const secondAttempt = await tryOnce();
|
|
if (secondAttempt.success) {
|
|
return { success: true, users: secondAttempt.users };
|
|
}
|
|
|
|
// GraphQL Followers regularly returns 404 (queryId churn / endpoint flakiness).
|
|
// Fallback to the legacy 1.1 endpoint so the CLI stays useful.
|
|
const restAttempt = await this.getFollowersViaRest(userId, count);
|
|
if (restAttempt.success) {
|
|
return restAttempt;
|
|
}
|
|
|
|
return { success: false, error: secondAttempt.error };
|
|
}
|
|
|
|
return { success: false, error: firstAttempt.error };
|
|
}
|
|
}
|
|
|
|
return TwitterClientUsers;
|
|
}
|