emusks 0.0.3 → 2.0.1

package/src/index.js

@@ -1,91 +1,161 @@
-import * as bookmarks from "./methods/bookmarks.js";
-import * as following from "./methods/follow.js";
-import * as liking from "./methods/like.js";
-import * as notifications from "./methods/notifications.js";
-import * as retweeting from "./methods/retweet.js";
-import * as search from "./methods/search.js";
-import * as timeline from "./methods/timeline.js";
-import * as tweeting from "./methods/tweet.js";
-import * as users from "./methods/users.js";
-
+import { ClientTransaction, handleXMigration } from "x-client-transaction-id";
 import parseUser from "./parsers/user.js";
-import headers from "./utils/headers.js";
+import getCycleTLS from "./cycletls.js";
+import clients from "./clients.js";
+import graphql from "./graphql.js";
+import v1_1 from "./v1.1.js";
+import v2 from "./v2.js";
+import flowLogin from "./flow.js";
+import initHelpers from "./helpers/index.js";
+
+export default class Emusks {
+  auth = null;
+  elevatedCookies = null;
+  graphql = graphql;
+  v1_1 = v1_1;
+  v2 = v2;
+
+  async elevate(password) {
+    if (!this.auth) throw new Error("must be logged in before calling elevate");
+
+    const res = await this.v1_1("account/verify_password", {
+      body: `password=${encodeURIComponent(password)}`,
+      headers: {
+        "content-type": "application/x-www-form-urlencoded",
+      },
+    });
 
-class Client {
-  auth = {};
-  user = null;
+    const setCookies = res.headers["Set-Cookie"] || [];
 
-  constructor({ authToken } = {}) {
-    if (authToken) {
-      this.auth.token = authToken;
+    const json = await res.json();
+    if (json.status !== "ok") {
+      throw new Error("invalid password");
     }
+
+    const cookieParts = [];
+    for (const setCookie of setCookies) {
+      const cookiePair = setCookie.split(";")[0];
+      if (cookiePair) {
+        cookieParts.push(cookiePair);
+      }
+    }
+
+    this.elevatedCookies = cookieParts.join("; ");
+
+    return json;
   }
 
-  async login() {
-    if (!this.auth.token) {
-      throw new Error("auth token is required to login");
+  async login(p) {
+    if (typeof p === "string") {
+      if (p.length > 50 || p.length < 20) {
+        throw new Error("invalid auth token length!");
+      }
+      p = { auth_token: p };
     }
 
-    // gets the csrf token from headers
-    const res = await fetch("https://pro.x.com/", {
+    if (p.type === "password") {
+      if (!p.username) throw new Error("username is required for password login");
+      if (!p.password) throw new Error("password is required for password login");
+
+      const flowResult = await flowLogin({
+        username: p.username,
+        password: p.password,
+        email: p.email,
+        phone: p.phone,
+        onRequest: p.onRequest,
+        proxy: p.proxy,
+      });
+
+      p = {
+        auth_token: flowResult.authToken,
+        client: p.client,
+        proxy: p.proxy,
+      };
+    }
+
+    if (!p.client) p.client = "web";
+    if (!p.auth_token) throw new Error("auth_token is required!");
+    if (typeof p.client === "string") p.client = clients[p.client];
+    if (!p.client) throw new Error("invalid client!");
+    if (p.proxy) this.proxy = p.proxy;
+
+    p.client.headers = {
+      "accept-language": "en-US,en;q=0.9",
+      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-site",
+      "sec-gpc": "1",
+    };
+
+    const cycleTLS = await getCycleTLS();
+    const res = await cycleTLS("https://x.com/", {
       headers: {
         accept:
           "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-        cookie: `auth_token=${this.auth.token};`,
-
-        ...headers,
+        cookie: `auth_token=${p.auth_token};`,
+        ...p.client.headers,
       },
+      userAgent: p.client.fingerprints.userAgent,
+      ja3: p.client.fingerprints.ja3,
+      ja4r: p.client.fingerprints.ja4r,
+      proxy: p.proxy || undefined,
+      referrer: "https://x.com/",
     });
 
-    const csrfToken = res.headers
-      .get("set-cookie")
-      .split(", ct0=")[1]
-      .split(";")[0];
+    const setCookies = res.headers["Set-Cookie"] || [];
+    const csrfToken = setCookies
+      .find((c) => c?.startsWith?.("ct0="))
+      ?.split?.(";")?.[0]
+      ?.split?.("=")?.[1];
 
     if (!csrfToken) {
       throw new Error("[emusks] failed to log in");
     }
 
+    this.auth = p;
     this.auth.csrfToken = csrfToken;
-    this.auth.cookies = `auth_token=${this.auth.token}; ct0=${csrfToken};`;
 
-    const initialStateMatch = (await res.text()).match(
-      /window\.__INITIAL_STATE__\s*=\s*({.*?});/s
-    );
+    const cookieParts = [`auth_token=${p.auth_token}`];
+    for (const setCookie of setCookies) {
+      const cookiePair = setCookie.split(";")[0];
+      if (cookiePair && !cookiePair.startsWith("auth_token=")) {
+        cookieParts.push(cookiePair);
+      }
+    }
+    this.auth.client.headers.cookie = cookieParts.join("; ");
+
+    const responseText = await res.text();
+    const initialStateMatch = responseText.match(/window\.__INITIAL_STATE__\s*=\s*({.*?});/s);
 
     if (!initialStateMatch) {
-      console.error(
-        "[emusks] failed to extract initial state from response. auth will work, \n         but user data will not be available (reason: no match)"
-      );
+      console.warn("[emusks] failed to extract initial state from response");
       return;
     }
 
-    const usersEntities = JSON.parse(initialStateMatch[1])?.entities?.users
-      ?.entities;
+    const initialState = JSON.parse(initialStateMatch[1]);
+    const usersEntities = initialState?.entities?.users?.entities;
     const initialStateUser = usersEntities && Object.values(usersEntities)[0];
 
     if (!initialStateUser) {
-      console.error(
-        "[emusks] failed to extract initial state from response. auth will work, \n         but user data will not be available (reason: user not parsed)"
-      );
+      console.warn("[emusks] failed to extract user from initial state");
       return;
     }
 
     this.user = parseUser(initialStateUser);
-    this.settings = JSON.parse(initialStateMatch[1])?.settings?.remote?.settings;
+    this.settings = initialState?.settings?.remote?.settings;
+
+    const document = await handleXMigration();
+    const transaction = new ClientTransaction(document);
+    await transaction.initialize();
+    this.auth.generateTransactionId = transaction.generateTransactionId.bind(transaction);
+
+    const helpers = initHelpers(this);
+    Object.assign(this, helpers);
 
     return this.user;
   }
-}
-
-Object.assign(Client.prototype, tweeting);
-Object.assign(Client.prototype, retweeting);
-Object.assign(Client.prototype, liking);
-Object.assign(Client.prototype, following);
-Object.assign(Client.prototype, bookmarks);
-Object.assign(Client.prototype, notifications);
-Object.assign(Client.prototype, search);
-Object.assign(Client.prototype, users);
-Object.assign(Client.prototype, timeline);
-
-export default Client;
+}

package/src/parsers/timeline.js

@@ -0,0 +1,105 @@
+import parseTweet from "./tweet.js";
+import parseUser from "./user.js";
+
+function findInstructions(obj) {
+  if (!obj || typeof obj !== "object") return null;
+
+  if (Array.isArray(obj.instructions)) {
+    return obj.instructions;
+  }
+
+  for (const key of Object.keys(obj)) {
+    const val = obj[key];
+    if (val && typeof val === "object") {
+      const found = findInstructions(val);
+      if (found) return found;
+    }
+  }
+
+  return null;
+}
+
+function extractTweetFromEntry(entry) {
+  const tweetResult =
+    entry?.content?.itemContent?.tweet_results?.result ||
+    entry?.item?.itemContent?.tweet_results?.result;
+  if (tweetResult) {
+    return parseTweet(tweetResult);
+  }
+  return null;
+}
+
+function extractUserFromEntry(entry) {
+  const userResult =
+    entry?.content?.itemContent?.user_results?.result ||
+    entry?.item?.itemContent?.user_results?.result;
+  if (userResult) {
+    return parseUser(userResult);
+  }
+  return null;
+}
+
+export default function parseTimeline(raw) {
+  const instructions = findInstructions(raw?.data || raw);
+
+  if (!instructions) {
+    return { tweets: [], users: [], nextCursor: null, previousCursor: null, raw };
+  }
+
+  const tweets = [];
+  const users = [];
+  let nextCursor = null;
+  let previousCursor = null;
+
+  for (const instruction of instructions) {
+    if (instruction.type === "TimelineAddEntries" || instruction.entries) {
+      for (const entry of instruction.entries || []) {
+        processEntry(entry, tweets, users);
+
+        if (entry.entryId?.startsWith("cursor-bottom") || entry.entryId?.includes("cursor-bottom")) {
+          nextCursor =
+            entry.content?.value || entry.content?.itemContent?.value || null;
+        }
+        if (entry.entryId?.startsWith("cursor-top") || entry.entryId?.includes("cursor-top")) {
+          previousCursor =
+            entry.content?.value || entry.content?.itemContent?.value || null;
+        }
+      }
+    }
+
+    if (instruction.type === "TimelineReplaceEntry" && instruction.entry) {
+      processEntry(instruction.entry, tweets, users);
+      if (instruction.entry.entryId?.includes("cursor-bottom")) {
+        nextCursor =
+          instruction.entry.content?.value ||
+          instruction.entry.content?.itemContent?.value ||
+          null;
+      }
+    }
+  }
+
+  return { tweets, users, nextCursor, previousCursor, raw };
+}
+
+function processEntry(entry, tweets, users) {
+  const tweet = extractTweetFromEntry(entry);
+  if (tweet) {
+    tweets.push(tweet);
+    return;
+  }
+
+  const user = extractUserFromEntry(entry);
+  if (user) {
+    users.push(user);
+    return;
+  }
+
+  if (entry.content?.items) {
+    for (const item of entry.content.items) {
+      const t = extractTweetFromEntry(item);
+      if (t) tweets.push(t);
+      const u = extractUserFromEntry(item);
+      if (u) users.push(u);
+    }
+  }
+}