528 lines
18 KiB
TypeScript
528 lines
18 KiB
TypeScript
import { parse as devalueParse } from 'devalue';
|
|
|
|
export interface SweetisticsClientOptions {
|
|
baseUrl: string;
|
|
apiKey: string;
|
|
userAgent?: string;
|
|
}
|
|
|
|
export interface SweetisticsTweetResult {
|
|
success: boolean;
|
|
tweetId?: string;
|
|
error?: string;
|
|
}
|
|
|
|
export interface SweetisticsTweet {
|
|
id: string;
|
|
text: string;
|
|
author: {
|
|
username: string;
|
|
name: string;
|
|
};
|
|
createdAt?: string;
|
|
replyCount?: number;
|
|
retweetCount?: number;
|
|
likeCount?: number;
|
|
conversationId?: string;
|
|
inReplyToStatusId?: string;
|
|
}
|
|
|
|
export interface SweetisticsTimelineResult {
|
|
success: boolean;
|
|
tweets?: SweetisticsTweet[];
|
|
error?: string;
|
|
}
|
|
|
|
export interface SweetisticsReadResult {
|
|
success: boolean;
|
|
tweet?: SweetisticsTweet;
|
|
error?: string;
|
|
}
|
|
|
|
export interface SweetisticsUserResult {
|
|
success: boolean;
|
|
user?: {
|
|
id: string;
|
|
username?: string | null;
|
|
name?: string | null;
|
|
email?: string | null;
|
|
profileImageUrl?: string | null;
|
|
};
|
|
error?: string;
|
|
}
|
|
|
|
type TrpcResponseEnvelope = { result?: { data?: unknown; error?: unknown } };
|
|
|
|
function normalizeBaseUrl(value: string): string {
|
|
const trimmed = value.trim();
|
|
if (!trimmed) return 'https://sweetistics.com';
|
|
return trimmed.endsWith('/') ? trimmed.slice(0, -1) : trimmed;
|
|
}
|
|
|
|
export class SweetisticsClient {
|
|
private readonly baseUrl: string;
|
|
private readonly apiKey: string;
|
|
private readonly userAgent?: string;
|
|
// Prevent hanging requests; keep Sweetistics calls snappy for CLI users.
|
|
private static readonly REQUEST_TIMEOUT_MS = 15_000;
|
|
|
|
constructor(options: SweetisticsClientOptions) {
|
|
this.baseUrl = normalizeBaseUrl(options.baseUrl);
|
|
this.apiKey = options.apiKey.trim();
|
|
this.userAgent = options.userAgent;
|
|
if (!this.apiKey) {
|
|
throw new Error('Sweetistics API key is required');
|
|
}
|
|
}
|
|
|
|
async tweet(text: string, replyToTweetId?: string, mediaIds?: string[]): Promise<SweetisticsTweetResult> {
|
|
const payload: Record<string, unknown> = { text };
|
|
if (replyToTweetId) {
|
|
payload.replyToTweetId = replyToTweetId;
|
|
}
|
|
if (mediaIds && mediaIds.length > 0) {
|
|
payload.mediaIds = mediaIds;
|
|
}
|
|
|
|
let response: Response;
|
|
try {
|
|
response = await this.fetchWithTimeout(`${this.baseUrl}/api/actions/tweet`, {
|
|
method: 'POST',
|
|
headers: {
|
|
authorization: `Bearer ${this.apiKey}`,
|
|
'content-type': 'application/json',
|
|
...(this.userAgent ? { 'user-agent': this.userAgent } : {}),
|
|
},
|
|
body: JSON.stringify(payload),
|
|
});
|
|
} catch (error) {
|
|
return { success: false, error: this.normalizeError(error) };
|
|
}
|
|
|
|
let data: unknown;
|
|
try {
|
|
data = await response.json();
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: `Sweetistics response parse failed: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
|
|
const success =
|
|
typeof (data as { success?: unknown })?.success === 'boolean' ? (data as { success: boolean }).success : false;
|
|
const tweetId =
|
|
typeof (data as { tweetId?: unknown })?.tweetId === 'string' ? (data as { tweetId?: string }).tweetId : undefined;
|
|
const errorMessage =
|
|
typeof (data as { error?: unknown })?.error === 'string' ? (data as { error?: string }).error : undefined;
|
|
|
|
if (!response.ok || !success) {
|
|
const reason = errorMessage || `HTTP ${response.status}`;
|
|
return { success: false, error: reason };
|
|
}
|
|
|
|
return { success: true, tweetId };
|
|
}
|
|
|
|
async read(tweetId: string): Promise<SweetisticsReadResult> {
|
|
// Public REST route that returns a single tweet record
|
|
const url = `${this.baseUrl}/api/tweets/${encodeURIComponent(tweetId)}`;
|
|
let response: Response;
|
|
try {
|
|
response = await this.fetchWithTimeout(url, {
|
|
headers: {
|
|
authorization: `Bearer ${this.apiKey}`,
|
|
...(this.userAgent ? { 'user-agent': this.userAgent } : {}),
|
|
},
|
|
});
|
|
} catch (error) {
|
|
return { success: false, error: this.normalizeError(error) };
|
|
}
|
|
|
|
if (!response.ok) {
|
|
return { success: false, error: `HTTP ${response.status}` };
|
|
}
|
|
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
let data: any;
|
|
try {
|
|
data = await response.json();
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: `Sweetistics response parse failed: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
|
|
if (!data?.id || !data?.author) {
|
|
return { success: false, error: 'Malformed tweet payload from Sweetistics' };
|
|
}
|
|
|
|
const tweet: SweetisticsTweet = {
|
|
id: String(data.id),
|
|
text: String(data.text ?? ''),
|
|
author: {
|
|
username: String(data.author.username ?? ''),
|
|
name: String(data.author.name ?? ''),
|
|
},
|
|
createdAt: data.createdAt,
|
|
replyCount: data.metrics?.replyCount,
|
|
retweetCount: data.metrics?.retweetCount,
|
|
likeCount: data.metrics?.likeCount,
|
|
conversationId: data.conversationId,
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
inReplyToStatusId: data.referencedTweets?.find?.((r: any) => r?.type === 'replied_to')?.id,
|
|
};
|
|
|
|
return { success: true, tweet };
|
|
}
|
|
|
|
async replies(tweetId: string): Promise<SweetisticsTimelineResult> {
|
|
return this.fetchConversation(tweetId, { excludeRoot: true });
|
|
}
|
|
|
|
async thread(tweetId: string): Promise<SweetisticsTimelineResult> {
|
|
return this.fetchConversation(tweetId, { excludeRoot: false });
|
|
}
|
|
|
|
async search(query: string, count: number): Promise<SweetisticsTimelineResult> {
|
|
const payload = {
|
|
query,
|
|
capabilities: [
|
|
{
|
|
resource: 'tweets',
|
|
source: 'postgres',
|
|
limit: Math.max(1, Math.min(count, 50)),
|
|
offset: 0,
|
|
detail: 'summary',
|
|
includeRetweets: true,
|
|
},
|
|
],
|
|
};
|
|
|
|
let response: Response;
|
|
try {
|
|
response = await this.fetchWithTimeout(`${this.baseUrl}/api/trpc/search.execute?batch=1`, {
|
|
method: 'POST',
|
|
headers: {
|
|
authorization: `Bearer ${this.apiKey}`,
|
|
'content-type': 'application/json',
|
|
...(this.userAgent ? { 'user-agent': this.userAgent } : {}),
|
|
},
|
|
body: JSON.stringify({ 0: { json: payload } }),
|
|
});
|
|
} catch (error) {
|
|
return { success: false, error: this.normalizeError(error) };
|
|
}
|
|
|
|
if (!response.ok) {
|
|
return { success: false, error: `HTTP ${response.status}` };
|
|
}
|
|
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
let body: any;
|
|
try {
|
|
body = await response.json();
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: `Sweetistics response parse failed: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
|
|
const envelope = Array.isArray(body) ? body[0] : body;
|
|
if (envelope?.error) {
|
|
const message = envelope.error?.message ?? 'Unknown search error';
|
|
return { success: false, error: message };
|
|
}
|
|
const dataField = envelope?.result?.data;
|
|
if (!dataField) {
|
|
return { success: false, error: 'Missing data in Sweetistics search response' };
|
|
}
|
|
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
let parsed: any;
|
|
try {
|
|
parsed = typeof dataField === 'string' ? devalueParse(dataField) : dataField;
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: `Sweetistics search decode failed: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
|
|
const tweetsSection = parsed?.tweets;
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
const items: any[] = tweetsSection?.items ?? [];
|
|
if (items.length === 0) {
|
|
return { success: true, tweets: [] };
|
|
}
|
|
|
|
const tweets: SweetisticsTweet[] = items.map((item) => {
|
|
const authorUsername = item.authorUsername || item.username || item.full?.author?.username || '';
|
|
const authorName = item.authorName || item.full?.author?.name || authorUsername;
|
|
const createdAt =
|
|
typeof item.createdAt === 'string'
|
|
? item.createdAt
|
|
: (item.createdAt?.toString?.() ??
|
|
(Array.isArray(item.createdAt) && item.createdAt[0] === 'Date' ? item.createdAt[1] : undefined));
|
|
const metrics = item.full?.metrics ?? item.full ?? item;
|
|
|
|
return {
|
|
id: String(item.id),
|
|
text: String(item.text ?? item.full?.text ?? ''),
|
|
author: { username: String(authorUsername), name: String(authorName) },
|
|
createdAt,
|
|
replyCount: metrics?.replyCount ?? metrics?.replies ?? 0,
|
|
retweetCount: metrics?.retweetCount ?? metrics?.retweets ?? 0,
|
|
likeCount: metrics?.likeCount ?? metrics?.likes ?? 0,
|
|
conversationId: item.conversationId ?? item.full?.conversationId,
|
|
inReplyToStatusId: item.full?.inReplyToStatusId ?? undefined,
|
|
};
|
|
});
|
|
|
|
return { success: true, tweets };
|
|
}
|
|
|
|
async getCurrentUser(): Promise<SweetisticsUserResult> {
|
|
const headers = {
|
|
authorization: `Bearer ${this.apiKey}`,
|
|
'content-type': 'application/json',
|
|
...(this.userAgent ? { 'user-agent': this.userAgent } : {}),
|
|
} satisfies Record<string, string>;
|
|
|
|
let response: Response;
|
|
try {
|
|
response = await this.fetchWithTimeout(`${this.baseUrl}/api/trpc/user.getCurrent?batch=1`, {
|
|
method: 'POST',
|
|
headers,
|
|
body: JSON.stringify({ 0: { json: null } }),
|
|
});
|
|
} catch (error) {
|
|
return { success: false, error: this.normalizeError(error) };
|
|
}
|
|
|
|
// Some deployments only allow GET for queries; fall back if POST is not allowed
|
|
if (response.status === 405) {
|
|
try {
|
|
response = await this.fetchWithTimeout(
|
|
`${this.baseUrl}/api/trpc/user.getCurrent?input=${encodeURIComponent('null')}`,
|
|
{
|
|
method: 'GET',
|
|
headers,
|
|
}
|
|
);
|
|
} catch (error) {
|
|
return { success: false, error: this.normalizeError(error) };
|
|
}
|
|
}
|
|
|
|
if (!response.ok) {
|
|
return { success: false, error: `HTTP ${response.status}` };
|
|
}
|
|
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
let body: any;
|
|
try {
|
|
body = await response.json();
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: `Sweetistics response parse failed: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
|
|
const envelope = Array.isArray(body) ? body[0] : body;
|
|
const maybeError = envelope?.error?.message || envelope?.result?.error?.message;
|
|
if (maybeError) {
|
|
return { success: false, error: String(maybeError) };
|
|
}
|
|
|
|
let data = envelope?.result?.data?.json ?? envelope?.result?.data ?? envelope?.json ?? envelope;
|
|
|
|
try {
|
|
if (typeof data === 'string') {
|
|
data = devalueParse(data);
|
|
} else if (data && typeof data === 'object' && 'json' in (data as Record<string, unknown>)) {
|
|
const inner = (data as Record<string, unknown>).json;
|
|
data = typeof inner === 'string' ? devalueParse(inner) : inner;
|
|
}
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: `Sweetistics response decode failed: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
|
|
const user = data && typeof data === 'object' ? data : null;
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
if (!user || typeof (user as any).id !== 'string') {
|
|
return { success: false, error: 'Malformed user payload from Sweetistics' };
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
user: {
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
id: String((user as any).id),
|
|
username:
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
(user as any).username ?? (user as any).twitterUsername ?? null,
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
name: (user as any).name ?? null,
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
email: (user as any).email ?? null,
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
profileImageUrl: (user as any).profileImageUrl ?? null,
|
|
},
|
|
};
|
|
}
|
|
|
|
private async fetchConversation(
|
|
tweetId: string,
|
|
options: { excludeRoot: boolean; force?: boolean } = { excludeRoot: false, force: true },
|
|
): Promise<SweetisticsTimelineResult> {
|
|
const url = new URL(`${this.baseUrl}/api/trpc/tweets.getConversation`);
|
|
const input: Record<string, unknown> = { tweetId };
|
|
// Always request a fresh conversation to avoid cached Sweetistics data unless explicitly disabled
|
|
if (options.force ?? true) {
|
|
input.force = 'true';
|
|
}
|
|
url.searchParams.set('input', JSON.stringify(input));
|
|
|
|
let response: Response;
|
|
try {
|
|
response = await this.fetchWithTimeout(url.toString(), {
|
|
headers: {
|
|
authorization: `Bearer ${this.apiKey}`,
|
|
...(this.userAgent ? { 'user-agent': this.userAgent } : {}),
|
|
},
|
|
});
|
|
} catch (error) {
|
|
return { success: false, error: this.normalizeError(error) };
|
|
}
|
|
|
|
if (!response.ok) {
|
|
return { success: false, error: `HTTP ${response.status}` };
|
|
}
|
|
|
|
let envelope: TrpcResponseEnvelope;
|
|
try {
|
|
envelope = (await response.json()) as TrpcResponseEnvelope;
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: `Sweetistics response parse failed: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
|
|
if (!envelope?.result?.data) {
|
|
return { success: false, error: 'Missing data in Sweetistics response' };
|
|
}
|
|
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
let parsed: any;
|
|
try {
|
|
const raw =
|
|
typeof envelope.result.data === 'string' ? devalueParse(envelope.result.data as string) : envelope.result.data;
|
|
parsed = raw;
|
|
} catch (error) {
|
|
return {
|
|
success: false,
|
|
error: `Sweetistics response decode failed: ${error instanceof Error ? error.message : String(error)}`,
|
|
};
|
|
}
|
|
|
|
const tweetIds: string[] = Array.isArray(parsed?.tweetIds) ? parsed.tweetIds.map(String) : [];
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
const tweetsMap: Record<string, any> = parsed?.tweets ?? {};
|
|
|
|
if (tweetIds.length === 0 || Object.keys(tweetsMap).length === 0) {
|
|
return { success: false, error: 'Conversation empty or unavailable' };
|
|
}
|
|
|
|
const rootId = tweetId;
|
|
const filteredIds = options.excludeRoot ? tweetIds.filter((id) => id !== rootId) : tweetIds;
|
|
|
|
const tweets: SweetisticsTweet[] = filteredIds
|
|
.map((id) => tweetsMap[id])
|
|
.filter(Boolean)
|
|
// biome-ignore lint/suspicious/noExplicitAny: Sweetistics responses are loosely typed
|
|
.map((item: any) => ({
|
|
id: String(item.id),
|
|
text: String(item.text ?? ''),
|
|
author: {
|
|
username: String(item.author?.username ?? ''),
|
|
name: String(item.author?.name ?? ''),
|
|
},
|
|
createdAt: item.createdAt ?? item.timestamp ?? undefined,
|
|
replyCount: item.replyCount ?? item.metrics?.replyCount,
|
|
retweetCount: item.retweetCount ?? item.metrics?.retweetCount,
|
|
likeCount: item.likeCount ?? item.metrics?.likeCount,
|
|
conversationId: item.conversationId ?? undefined,
|
|
inReplyToStatusId: item.inReplyToStatusId ?? undefined,
|
|
}));
|
|
|
|
return { success: true, tweets };
|
|
}
|
|
|
|
async uploadMedia(input: { data: string; mimeType: string; alt?: string }): Promise<{ success: boolean; mediaId?: string; error?: string }> {
|
|
try {
|
|
const response = await this.fetchWithTimeout(`${this.baseUrl}/api/actions/media/upload`, {
|
|
method: 'POST',
|
|
headers: {
|
|
authorization: `Bearer ${this.apiKey}`,
|
|
'content-type': 'application/json',
|
|
...(this.userAgent ? { 'user-agent': this.userAgent } : {}),
|
|
},
|
|
body: JSON.stringify(input),
|
|
});
|
|
|
|
let body: unknown;
|
|
try {
|
|
body = await response.json();
|
|
} catch (error) {
|
|
return { success: false, error: this.normalizeError(error) };
|
|
}
|
|
|
|
const mediaId =
|
|
typeof (body as { mediaId?: unknown })?.mediaId === 'string'
|
|
? (body as { mediaId: string }).mediaId
|
|
: undefined;
|
|
const errorMessage =
|
|
typeof (body as { error?: unknown })?.error === 'string' ? (body as { error: string }).error : undefined;
|
|
|
|
if (!response.ok || !mediaId) {
|
|
return { success: false, error: errorMessage ?? `HTTP ${response.status}` };
|
|
}
|
|
return { success: true, mediaId };
|
|
} catch (error) {
|
|
return { success: false, error: this.normalizeError(error) };
|
|
}
|
|
}
|
|
|
|
private async fetchWithTimeout(url: string, init?: RequestInit): Promise<Response> {
|
|
const controller = new AbortController();
|
|
const timeoutId = setTimeout(
|
|
() => controller.abort(new Error(`Request timed out after ${SweetisticsClient.REQUEST_TIMEOUT_MS}ms`)),
|
|
SweetisticsClient.REQUEST_TIMEOUT_MS,
|
|
);
|
|
|
|
try {
|
|
return await fetch(url, { ...init, signal: controller.signal });
|
|
} finally {
|
|
clearTimeout(timeoutId);
|
|
}
|
|
}
|
|
|
|
private normalizeError(error: unknown): string {
|
|
if (error instanceof Error) {
|
|
if ((error as { name?: string }).name === 'AbortError') {
|
|
return 'Request timed out';
|
|
}
|
|
return error.message;
|
|
}
|
|
return String(error);
|
|
}
|
|
}
|