emusks 2.0.10 → 2.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emusks",
-  "version": "2.0.10",
+  "version": "2.0.12",
   "description": "Reverse-engineered Twitter API client. Log in and interact with the unofficial X API using any client identity — web, Android, iOS, or TweetDeck",
   "keywords": [
     "client",

package/src/graphql.js

@@ -1,16 +1,60 @@
+import { ClientTransaction, handleXMigration } from "x-client-transaction-id";
 import getCycleTLS from "./cycletls.js";
 import graphqlApi from "./static/graphql.js";
 
+const GRAPHQL_ENDPOINTS = {
+  main: {
+    base: "https://api.x.com/graphql",
+    referrer: "https://x.com/",
+    secFetchSite: "same-site",
+  },
+  main_twitter: {
+    base: "https://api.twitter.com/graphql",
+    referrer: "https://twitter.com/",
+    secFetchSite: "same-site",
+  },
+  web: {
+    base: "https://x.com/i/api/graphql",
+    referrer: "https://x.com/",
+    secFetchSite: "same-origin",
+  },
+  web_twitter: {
+    base: "https://twitter.com/i/api/graphql",
+    referrer: "https://twitter.com/",
+    secFetchSite: "same-origin",
+  },
+  tweetdeck: {
+    base: "https://pro.x.com/i/api/graphql",
+    referrer: "https://pro.x.com/",
+    secFetchSite: "same-origin",
+  },
+  tweetdeck_twitter: {
+    base: "https://pro.twitter.com/i/api/graphql",
+    referrer: "https://pro.twitter.com/",
+    secFetchSite: "same-origin",
+  },
+};
+
+export { GRAPHQL_ENDPOINTS };
+
 export default async function graphql(queryName, { variables, fieldToggles, body, headers } = {}) {
   const entry = graphqlApi[queryName];
   if (!entry) {
     throw new Error(`graphql query ${queryName} not found`);
   }
 
-  const [method, baseUrl, features, queryId] = entry;
+  const [method, , features, queryId] = entry;
   const isPost = method.toLowerCase() === "post";
 
-  let finalUrl = baseUrl;
+  const endpointName = this.graphqlEndpoint || "web";
+  const endpoint = GRAPHQL_ENDPOINTS[endpointName];
+  if (!endpoint) {
+    throw new Error(
+      `unknown graphql endpoint "${endpointName}", expected: ${Object.keys(GRAPHQL_ENDPOINTS).join(", ")}`,
+    );
+  }
+
+  let finalUrl = `${endpoint.base}/${queryId}/${queryName}`;
   let requestBody;
 
   if (isPost) {
@@ -41,6 +85,9 @@ export default async function graphql(queryName, { variables, fieldToggles, body
   const url = new URL(finalUrl);
   const pathname = url.pathname;
 
+  const useTransactionIds =
+    this.transactionIds !== undefined ? this.transactionIds : endpointName === "web";
+
   const requestHeaders = {
     accept: "*/*",
     "accept-language": "en-US,en;q=0.9",
@@ -50,23 +97,32 @@ export default async function graphql(queryName, { variables, fieldToggles, body
     "x-twitter-active-user": "yes",
     "x-twitter-auth-type": "OAuth2Session",
     "x-twitter-client-language": "en",
-    "x-client-transaction-id": await this.auth.generateTransactionId(
-      method.toUpperCase(),
-      pathname,
-    ),
     priority: "u=1, i",
     "sec-ch-ua": '"Not(A:Brand";v="8", "Chromium";v="144"',
     "sec-ch-ua-mobile": "?0",
     "sec-ch-ua-platform": '"macOS"',
     "sec-fetch-dest": "empty",
     "sec-fetch-mode": "cors",
-    "sec-fetch-site": "same-origin",
+    "sec-fetch-site": endpoint.secFetchSite,
     "sec-gpc": "1",
     cookie:
       this.auth.client.headers.cookie + (this.elevatedCookies ? `; ${this.elevatedCookies}` : ""),
     ...headers,
   };
 
+  if (useTransactionIds) {
+    if (!this.auth.generateTransactionId) {
+      const document = await handleXMigration();
+      const transaction = new ClientTransaction(document);
+      await transaction.initialize();
+      this.auth.generateTransactionId = transaction.generateTransactionId.bind(transaction);
+    }
+    requestHeaders["x-client-transaction-id"] = await this.auth.generateTransactionId(
+      method.toUpperCase(),
+      pathname,
+    );
+  }
+
   const cycleTLS = await getCycleTLS();
   const res = await (
     await cycleTLS(
@@ -78,7 +134,7 @@ export default async function graphql(queryName, { variables, fieldToggles, body
         ja4r: this.auth.client.fingerprints.ja4r,
         body: isPost ? JSON.stringify(requestBody) : undefined,
         proxy: this.proxy || undefined,
-        referrer: "https://x.com/",
+        referrer: endpoint.referrer,
       },
       method,
     )

package/src/helpers/media.js

@@ -23,8 +23,7 @@ const MIME_BY_EXT = {
 
 function detectMediaType(buf) {
   if (buf[0] === 0xff && buf[1] === 0xd8) return "image/jpeg";
-  if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47)
-    return "image/png";
+  if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) return "image/png";
   if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46) return "image/gif";
   if (
     buf[0] === 0x52 &&
@@ -37,16 +36,9 @@ function detectMediaType(buf) {
     buf[11] === 0x50
   )
     return "image/webp";
-  if (
-    buf.length > 7 &&
-    buf[4] === 0x66 &&
-    buf[5] === 0x74 &&
-    buf[6] === 0x79 &&
-    buf[7] === 0x70
-  )
+  if (buf.length > 7 && buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70)
     return "video/mp4";
-  if (buf[0] === 0x1a && buf[1] === 0x45 && buf[2] === 0xdf && buf[3] === 0xa3)
-    return "video/webm";
+  if (buf[0] === 0x1a && buf[1] === 0x45 && buf[2] === 0xdf && buf[3] === 0xa3) return "video/webm";
   return null;
 }
 
@@ -59,31 +51,15 @@ function getMediaCategory(mediaType, uploadType) {
 
 function checkMediaSize(category, size) {
   const fmt = (x) => `${(x / 1e6).toFixed(2)} MB`;
-  if (
-    category.includes("image") &&
-    !category.includes("gif") &&
-    size > MAX_IMAGE_SIZE
-  )
-    throw new Error(
-      `cannot upload ${fmt(size)} image \u2014 max is ${fmt(MAX_IMAGE_SIZE)}`,
-    );
+  if (category.includes("image") && !category.includes("gif") && size > MAX_IMAGE_SIZE)
+    throw new Error(`cannot upload ${fmt(size)} image \u2014 max is ${fmt(MAX_IMAGE_SIZE)}`);
   if (category.includes("gif") && size > MAX_GIF_SIZE)
-    throw new Error(
-      `cannot upload ${fmt(size)} gif \u2014 max is ${fmt(MAX_GIF_SIZE)}`,
-    );
+    throw new Error(`cannot upload ${fmt(size)} gif \u2014 max is ${fmt(MAX_GIF_SIZE)}`);
   if (category.includes("video") && size > MAX_VIDEO_SIZE)
-    throw new Error(
-      `cannot upload ${fmt(size)} video \u2014 max is ${fmt(MAX_VIDEO_SIZE)}`,
-    );
+    throw new Error(`cannot upload ${fmt(size)} video \u2014 max is ${fmt(MAX_VIDEO_SIZE)}`);
 }
 
-async function makeUploadRequest(
-  instance,
-  method,
-  params,
-  body,
-  extraHeaders = {},
-) {
+async function makeUploadRequest(instance, method, params, body, extraHeaders = {}) {
   const cycleTLS = await getCycleTLS();
   const url = `${UPLOAD_URL}?${new URLSearchParams(params).toString()}`;
 
@@ -96,9 +72,9 @@ async function makeUploadRequest(
     "x-twitter-auth-type": "OAuth2Session",
     "x-twitter-client-language": "en",
     priority: "u=1, i",
-    "sec-ch-ua": 'Not(A:Brand;v=8, Chromium;v=144',
+    "sec-ch-ua": "Not(A:Brand;v=8, Chromium;v=144",
     "sec-ch-ua-mobile": "?0",
-    "sec-ch-ua-platform": 'macOS',
+    "sec-ch-ua-platform": "macOS",
     "sec-fetch-dest": "empty",
     "sec-fetch-mode": "cors",
     "sec-fetch-site": "same-site",
@@ -138,10 +114,7 @@ export async function create(source, opts = {}) {
   } else if (typeof Blob !== "undefined" && source instanceof Blob) {
     buf = Buffer.from(await source.arrayBuffer());
     if (!mediaType) mediaType = source.type || undefined;
-  } else if (
-    source instanceof ArrayBuffer ||
-    source instanceof SharedArrayBuffer
-  ) {
+  } else if (source instanceof ArrayBuffer || source instanceof SharedArrayBuffer) {
     buf = Buffer.from(source);
   } else if (Buffer.isBuffer(source) || source instanceof Uint8Array) {
     buf = Buffer.from(source);
@@ -153,9 +126,7 @@ export async function create(source, opts = {}) {
 
   if (!mediaType) mediaType = detectMediaType(buf);
   if (!mediaType)
-    throw new Error(
-      "could not detect media type \u2014 pass opts.mediaType (e.g. 'image/png')",
-    );
+    throw new Error("could not detect media type \u2014 pass opts.mediaType (e.g. 'image/png')");
 
   const totalBytes = buf.length;
   const uploadType = opts.type === "dm" ? "dm" : "tweet";
@@ -177,10 +148,7 @@ export async function create(source, opts = {}) {
 
   let segmentIndex = 0;
   for (let offset = 0; offset < totalBytes; offset += CHUNK_SIZE) {
-    const chunk = buf.slice(
-      offset,
-      Math.min(offset + CHUNK_SIZE, totalBytes),
-    );
+    const chunk = buf.slice(offset, Math.min(offset + CHUNK_SIZE, totalBytes));
     const base64 = chunk.toString("base64");
 
     await makeUploadRequest(
@@ -205,23 +173,17 @@ export async function create(source, opts = {}) {
 
   const finalizeData = await finalizeRes.json();
   if (finalizeData?.error) {
-    throw new Error(
-      `upload FINALIZE failed: ${JSON.stringify(finalizeData)}`,
-    );
+    throw new Error(`upload FINALIZE failed: ${JSON.stringify(finalizeData)}`);
   }
 
   let processingInfo = finalizeData?.processing_info;
   while (processingInfo) {
     if (processingInfo.error) {
-      throw new Error(
-        `media processing error: ${JSON.stringify(processingInfo.error)}`,
-      );
+      throw new Error(`media processing error: ${JSON.stringify(processingInfo.error)}`);
     }
     if (processingInfo.state === "succeeded") break;
     if (processingInfo.state === "failed") {
-      throw new Error(
-        `media processing failed: ${JSON.stringify(processingInfo)}`,
-      );
+      throw new Error(`media processing failed: ${JSON.stringify(processingInfo)}`);
     }
 
     const wait = (processingInfo.check_after_secs || 2) * 1000;
@@ -247,6 +209,61 @@ export async function create(source, opts = {}) {
   return { media_id: mediaId, ...finalizeData };
 }
 
+export async function createFromUrl(url, opts = {}) {
+  if (!this.auth) throw new Error("you must be logged in to upload media");
+
+  const mediaType = opts.mediaType || "image/gif";
+  const uploadType = opts.type === "dm" ? "dm" : "tweet";
+  const category = opts.mediaCategory || getMediaCategory(mediaType, uploadType);
+
+  const initRes = await makeUploadRequest(this, "post", {
+    command: "INIT",
+    source_url: url,
+    media_type: mediaType,
+    media_category: category,
+  });
+
+  const initData = await initRes.json();
+  if (!initData?.media_id_string) {
+    throw new Error(`upload INIT failed: ${JSON.stringify(initData)}`);
+  }
+  const mediaId = initData.media_id_string;
+
+  let processingInfo = initData?.processing_info;
+  while (processingInfo) {
+    if (processingInfo.error) {
+      throw new Error(`media processing error: ${JSON.stringify(processingInfo.error)}`);
+    }
+    if (processingInfo.state === "succeeded") break;
+    if (processingInfo.state === "failed") {
+      throw new Error(`media processing failed: ${JSON.stringify(processingInfo)}`);
+    }
+
+    const wait = (processingInfo.check_after_secs || 2) * 1000;
+    await new Promise((r) => setTimeout(r, wait));
+
+    const statusRes = await makeUploadRequest(this, "get", {
+      command: "STATUS",
+      media_id: mediaId,
+    });
+    const statusData = await statusRes.json();
+    processingInfo = statusData?.processing_info;
+  }
+
+  const metadataBody = { media_id: mediaId };
+  const altText = opts.altText || opts.alt_text;
+  if (altText) metadataBody.alt_text = { text: altText };
+  if (opts.origin) metadataBody.found_media_origin = opts.origin;
+
+  if (altText || opts.origin) {
+    await this.v1_1("media/metadata/create", {
+      body: JSON.stringify(metadataBody),
+    });
+  }
+
+  return { media_id: mediaId, ...initData };
+}
+
 export async function createMetadata(mediaId, altText, opts = {}) {
   const res = await this.v1_1("media/metadata/create", {
     body: JSON.stringify({
@@ -269,4 +286,4 @@ export async function createSubtitles(mediaId, subtitles) {
     }),
   });
   return await res.json();
-}
+}

package/src/helpers/tweets.js

@@ -4,30 +4,24 @@ import parseTweet from "../parsers/tweet.js";
 async function createPollCard(instance, poll) {
   if (!poll.choices || poll.choices.length < 2)
     throw new Error("a poll must have at least 2 choices");
-  if (poll.choices.length > 4)
-    throw new Error("a poll must not have more than 4 choices");
+  if (poll.choices.length > 4) throw new Error("a poll must not have more than 4 choices");
 
   const hasImages = poll.choices.some((c) => typeof c === "object" && c.image);
   const allImages = poll.choices.every((c) => typeof c === "object" && c.image);
   if (hasImages && !allImages)
-    throw new Error(
-      "either all poll choices must have images, or none of them",
-    );
+    throw new Error("either all poll choices must have images, or none of them");
 
   const labels = poll.choices.map((c) => (typeof c === "object" ? c.label : c));
 
   for (const label of labels) {
     if (typeof label !== "string" || label.length === 0)
       throw new Error("each poll choice must have a non-empty label");
-    if (label.length > 25)
-      throw new Error(`poll choice "${label}" exceeds the 25-character limit`);
+    if (label.length > 25) throw new Error(`poll choice "${label}" exceeds the 25-character limit`);
   }
 
   const duration = poll.duration_minutes ?? 1440;
   if (duration < 5 || duration > 10080)
-    throw new Error(
-      "poll duration must be between 5 and 10 080 minutes (7 days)",
-    );
+    throw new Error("poll duration must be between 5 and 10 080 minutes (7 days)");
 
   const cycleTLS = await getCycleTLS();
 
@@ -40,8 +34,7 @@ async function createPollCard(instance, poll) {
     cardObj["twitter:card"] = "poll_choice_images";
     for (let i = 0; i < poll.choices.length; i++) {
       cardObj[`twitter:string:choice${i + 1}_label`] = labels[i];
-      cardObj[`twitter:image:choice${i + 1}_image:src:id`] =
-        `mis://${poll.choices[i].image}`;
+      cardObj[`twitter:image:choice${i + 1}_image:src:id`] = `mis://${poll.choices[i].image}`;
     }
   } else {
     cardObj["twitter:card"] = `poll${poll.choices.length}choice_text_only`;
@@ -65,9 +58,9 @@ async function createPollCard(instance, poll) {
         "x-twitter-auth-type": "OAuth2Session",
         "x-twitter-client-language": "en",
         priority: "u=1, i",
-        "sec-ch-ua": 'Not(A:Brand;v=8, Chromium;v=144',
+        "sec-ch-ua": "Not(A:Brand;v=8, Chromium;v=144",
         "sec-ch-ua-mobile": "?0",
-        "sec-ch-ua-platform": 'macOS',
+        "sec-ch-ua-platform": "macOS",
         "sec-fetch-dest": "empty",
         "sec-fetch-mode": "cors",
         "sec-fetch-site": "same-site",
@@ -99,11 +92,28 @@ export async function create(text, opts = {}) {
   let cardUri = opts.cardUri;
 
   if (opts.poll) {
-    if (cardUri)
-      throw new Error("a tweet can\u0027t have both a poll and a cardUri");
+    if (cardUri) throw new Error("a tweet can\u0027t have both a poll and a cardUri");
     cardUri = await createPollCard(this, opts.poll);
   }
 
+  const mediaIds = opts.mediaIds ? [...opts.mediaIds] : [];
+
+  if (opts.gif) {
+    const gif = opts.gif;
+    const gifUrl = gif.original_image?.url || gif.url;
+    if (!gifUrl) throw new Error("gif must have a url or original_image.url");
+
+    const provider = gif.found_media_origin?.provider || gif.provider;
+    const gifId = gif.found_media_origin?.id || gif.id;
+    const altText = gif.alt_text || gif.altText;
+
+    const uploaded = await this.media.createFromUrl(gifUrl, {
+      origin: provider && gifId ? { provider, id: gifId } : undefined,
+      altText,
+    });
+    mediaIds.push(uploaded.media_id);
+  }
+
   const res = await this.graphql("CreateTweet", {
     body: {
       variables: {
@@ -111,21 +121,20 @@ export async function create(text, opts = {}) {
         dark_request: false,
         card_uri: cardUri || undefined,
         media: {
-          media_entities:
-            opts.mediaIds?.map((id) => ({
-              media_id: id,
-              tagged_users: [],
-            })) || [],
+          media_entities: mediaIds.map((id) => ({
+            media_id: id,
+            tagged_users: [],
+          })),
           possibly_sensitive: opts.sensitive || false,
         },
         semantic_annotation_ids: [],
         ...(opts.replyTo
           ? {
-            reply: {
-              in_reply_to_tweet_id: opts.replyTo,
-              exclude_reply_user_ids: [],
-            },
-          }
+              reply: {
+                in_reply_to_tweet_id: opts.replyTo,
+                exclude_reply_user_ids: [],
+              },
+            }
           : {}),
         ...(opts.quoteTweetId
           ? { attachment_url: `https://x.com/i/status/${opts.quoteTweetId}` }
@@ -159,11 +168,11 @@ export async function createNote(text, opts = {}) {
         richtext_options: { richtext_tags: opts.richtext_tags || [] },
         ...(opts.replyTo
           ? {
-            reply: {
-              in_reply_to_tweet_id: opts.replyTo,
-              exclude_reply_user_ids: [],
-            },
-          }
+              reply: {
+                in_reply_to_tweet_id: opts.replyTo,
+                exclude_reply_user_ids: [],
+              },
+            }
           : {}),
         ...opts.variables,
       },
@@ -248,9 +257,7 @@ export async function getMany(tweetIds) {
     },
   });
   const results = res?.data?.tweetResult || [];
-  return Array.isArray(results)
-    ? results.map((r) => (r?.result ? parseTweet(r.result) : r))
-    : res;
+  return Array.isArray(results) ? results.map((r) => (r?.result ? parseTweet(r.result) : r)) : res;
 }
 
 export async function detail(tweetId, opts = {}) {
@@ -398,4 +405,4 @@ export async function similar(tweetId) {
   return await this.graphql("SimilarPosts", {
     variables: { tweet_id: tweetId },
   });
-}
+}

package/src/index.js

@@ -2,7 +2,7 @@ import { ClientTransaction, handleXMigration } from "x-client-transaction-id";
 import clients from "./clients.js";
 import getCycleTLS from "./cycletls.js";
 import flowLogin from "./flow.js";
-import graphql from "./graphql.js";
+import graphql, { GRAPHQL_ENDPOINTS } from "./graphql.js";
 import initHelpers from "./helpers/index.js";
 import parseUser from "./parsers/user.js";
 import v1_1 from "./v1.1.js";
@@ -11,6 +11,8 @@ import v2 from "./v2.js";
 export default class Emusks {
   auth = null;
   elevatedCookies = null;
+  graphqlEndpoint = "web";
+  transactionIds = undefined;
 
   async elevate(password) {
     if (!this.auth) throw new Error("must be logged in before calling elevate");
@@ -76,6 +78,19 @@ export default class Emusks {
     if (!p.client) throw new Error("invalid client!");
     if (p.proxy) this.proxy = p.proxy;
 
+    if (p.endpoint) {
+      if (!GRAPHQL_ENDPOINTS[p.endpoint]) {
+        throw new Error(
+          `unknown graphql endpoint "${p.endpoint}", expected: ${Object.keys(GRAPHQL_ENDPOINTS).join(", ")}`,
+        );
+      }
+      this.graphqlEndpoint = p.endpoint;
+    }
+
+    if (p.transactionIds !== undefined) {
+      this.transactionIds = p.transactionIds;
+    }
+
     if (!p.client.bearer) {
       throw new Error("client is missing bearer token!");
     }
@@ -139,10 +154,17 @@ export default class Emusks {
     }
     this.auth.client.headers.cookie = cookieParts.join("; ");
 
-    const document = await handleXMigration();
-    const transaction = new ClientTransaction(document);
-    await transaction.initialize();
-    this.auth.generateTransactionId = transaction.generateTransactionId.bind(transaction);
+    const needsTransactionIds =
+      this.transactionIds !== undefined
+        ? this.transactionIds
+        : this.graphqlEndpoint === "web" || this.graphqlEndpoint === "web_twitter";
+
+    if (needsTransactionIds) {
+      const document = await handleXMigration();
+      const transaction = new ClientTransaction(document);
+      await transaction.initialize();
+      this.auth.generateTransactionId = transaction.generateTransactionId.bind(transaction);
+    }
 
     const responseText = await res.text();
     const initialStateMatch = responseText.match(/window\.__INITIAL_STATE__\s*=\s*({.*?});/s);