emusks 2.3.6 → 2.3.8

package/src/index.js

@@ -54,6 +54,8 @@ export default class Emusks {
   }
 
   async login(p) {
+    let loginCookies = {};
+    let loginClientProfile;
     if (typeof p === "string") {
       if (p.length > 50 || p.length < 20) {
         throw new Error("invalid auth token length!");
@@ -73,14 +75,21 @@ export default class Emusks {
         phone: p.phone,
         onRequest: p.onRequest,
         getCastleToken: p.getCastleToken,
+        castleProfile: p.castleProfile,
         proxy: p.proxy,
         debug: p.debug,
+        timeout: p.timeout,
       });
+      loginCookies = { ...flowResult.cookies };
+      loginClientProfile = flowResult.clientProfile;
+      if (flowResult.csrfToken) loginCookies.ct0 = flowResult.csrfToken;
 
       p = {
         auth_token: flowResult.authToken,
         client: p.client,
         proxy: p.proxy,
+        endpoint: p.endpoint,
+        transactionIds: p.transactionIds,
       };
     }
 
@@ -88,6 +97,7 @@ export default class Emusks {
     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!");
+    p.client = { ...p.client, fingerprints: p.client.fingerprints ? { ...p.client.fingerprints } : undefined };
     if (p.proxy) this.proxy = p.proxy;
 
     if (p.endpoint) {
@@ -127,44 +137,58 @@ export default class Emusks {
       "sec-fetch-mode": "cors",
       "sec-fetch-site": "same-site",
       "sec-gpc": "1",
+      ...loginClientProfile?.clientHints,
     };
 
+    if (loginClientProfile) {
+      p.client.userAgent = loginClientProfile.userAgent;
+      p.client.fingerprints.userAgent = loginClientProfile.userAgent;
+      p.client.fingerprints.ja3 = p.client.fingerprints.ja3.replace(/^771,/, "772,").replace("4588-", "");
+      delete p.client.fingerprints.ja4r;
+    }
     const cycleTLS = await getCycleTLS();
+    loginCookies.auth_token = p.auth_token;
     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=${p.auth_token};`,
+        cookie: Object.entries(loginCookies).map(([name, value]) => `${name}=${value}`).join("; "),
         ...p.client.headers,
       },
-      userAgent: p.client.fingerprints.userAgent,
+      userAgent: p.client.fingerprints.userAgent || p.client.fingerprints["user-agent"],
       ja3: p.client.fingerprints.ja3,
       ja4r: p.client.fingerprints.ja4r,
       proxy: p.proxy || undefined,
       referrer: "https://x.com/",
     });
 
-    const setCookies = res.headers["Set-Cookie"] || [];
-    const csrfToken = setCookies
-      .find((c) => c?.startsWith?.("ct0="))
-      ?.split?.(";")?.[0]
-      ?.split?.("=")?.[1];
+    if (res.status !== 200) throw new Error(`[emusks] session bootstrap failed: ${res.status}`);
+    const setCookie = res.headers?.["Set-Cookie"] ?? res.headers?.["set-cookie"] ?? [];
+    const setCookies = Array.isArray(setCookie) ? setCookie : [setCookie];
+    for (const cookie of setCookies) {
+      const [pair, ...attributes] = cookie.split(";");
+      const separator = pair.indexOf("=");
+      if (separator < 1) continue;
+      const name = pair.slice(0, separator).trim();
+      const attrs = Object.fromEntries(attributes.map((attribute) => {
+        const [key, ...parts] = attribute.trim().split("=");
+        return [key.toLowerCase(), parts.join("=")];
+      }));
+      const maxAge = /^-?\d+$/.test(attrs["max-age"] ?? "") ? Number(attrs["max-age"]) : null;
+      const expired = maxAge !== null ? maxAge <= 0 : Date.parse(attrs.expires) <= Date.now();
+      if (expired) delete loginCookies[name];
+      else loginCookies[name] = pair.slice(separator + 1).trim();
+    }
+    const csrfToken = loginCookies.ct0;
 
-    if (!csrfToken) {
+    if (!csrfToken || !loginCookies.auth_token) {
       throw new Error("[emusks] failed to log in");
     }
 
     this.auth = p;
     this.auth.csrfToken = csrfToken;
-
-    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("; ");
+    this.auth.auth_token = loginCookies.auth_token;
+    this.auth.client.headers.cookie = Object.entries(loginCookies).map(([name, value]) => `${name}=${value}`).join("; ");
 
     const needsTransactionIds =
       this.transactionIds !== undefined

package/src/parsers/jetfuel-messages.js

@@ -0,0 +1,121 @@
+export function decodeJetfuelMessages(input) {
+  const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const strings = [];
+  const messages = [];
+  let offset = 0;
+  let end = bytes.length;
+  const take = (length) => {
+    if (offset + length > end) throw new Error("truncated jetfuel message");
+    const start = offset;
+    offset += length;
+    return start;
+  };
+  const u8 = () => view.getUint8(take(1));
+  const uint = () => {
+    let value = 0;
+    for (let shift = 0; shift < 49; shift += 7) {
+      const byte = u8();
+      value += (byte & 127) * 2 ** shift;
+      if (!(byte & 128)) return value;
+    }
+    throw new Error("invalid jetfuel integer");
+  };
+  const i16 = () => view.getInt16(take(2), true);
+  const i32 = () => view.getInt32(take(4), true);
+  const i64 = () => view.getBigInt64(take(8), true);
+  const f64 = () => view.getFloat64(take(8), true);
+  const bool = () => Boolean(u8());
+  const str = () => {
+    const length = uint();
+    const start = take(length);
+    const value = new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(start, start + length));
+    strings.push(value);
+    return value;
+  };
+  const tuple = (...readers) => () => readers.map((read) => read());
+  const list = (read) => () => {
+    const count = uint();
+    if (count > end - offset) throw new Error("invalid jetfuel list length");
+    return Array.from({ length: count }, read);
+  };
+  const dict = (key, value) => () => new Map(list(tuple(key, value))());
+  const optional = (read) => () => bool() ? read() : null;
+  const record = (fields) => () => Object.fromEntries(Object.entries(fields).map(([key, read]) => [key, read()]));
+  const constant = (value) => () => value;
+  const variant = (schema) => {
+    let readers;
+    const read = () => {
+      const tag = u8();
+      if (!readers[tag]) throw new Error(`unknown jetfuel tag ${tag}`);
+      return [tag, readers[tag]()];
+    };
+    readers = typeof schema === "function" ? schema(read) : schema;
+    return read;
+  };
+  const element = record({ type: i16, props: dict(i16, uint), children: list(uint), id: optional(i64), extend: optional(uint) });
+  const ref = variant({
+    0: record({ id: i64 }), 4: record({ id: i64, root: uint }),
+    1: record({ key: i16, root: uint }),
+    ...Object.fromEntries([2, 3, 7, 8].map((tag) => [tag, record({ key: str, root: uint })])),
+    ...Object.fromEntries([5, 6, 9, 10, 11].map((tag) => [tag, record({ root: uint })])),
+  });
+  const mutation = variant({
+    0: ref, 1: tuple(ref, uint), 2: tuple(ref, i16), 3: tuple(ref, str),
+    4: tuple(ref, uint, optional(i16)), 5: tuple(ref, uint),
+    6: tuple(ref, optional(tuple(uint, uint))), 7: tuple(ref, uint), 8: tuple(ref, uint),
+  });
+  const navigation = variant({
+    0: record({ url: uint, preview: optional(uint), replace: bool }),
+    9: record({ url: uint, preview: optional(uint), replace: bool }),
+    1: record({ url: uint, body: optional(uint), preview: optional(uint), replace: bool }),
+    8: record({ url: uint }), 7: record({ id: uint }),
+    ...Object.fromEntries([2, 3, 4, 5, 6].map((tag) => [tag, constant(null)])),
+  });
+  const action = variant((self) => ({
+    0: mutation, 1: record({ ref: uint, action: self, cancel: optional(self) }),
+    2: list(self), 3: record({ url: uint, body: uint, complete: optional(self), error: optional(self), optimistic: optional(self) }),
+    4: record({ action: self, intensity: i16 }), 5: record({ ref: uint, type: u8 }),
+    21: record({ ref: uint, duration: i16, animation: bool }),
+    19: record({ ref: uint, type: u8, allowsRotation: bool }),
+    20: record({ ref: uint, overlay: uint, mode: str }), 6: navigation,
+    7: record({ type: u8, id: optional(i64) }), 8: str,
+    9: record({ urls: list(str), priority: u8 }), 10: record({ action: str, ref: uint }),
+    11: record({ type: u8, ref: uint }), 12: record({ action: self, delaySeconds: i16 }),
+    13: record({ data: str, secret: str, knownDeviceToken: str }),
+    14: record({ text: str, dismissText: optional(str) }), 15: record({ ref: uint, to: uint }),
+    16: record({ ref: uint, fields: list(str) }), 17: record({ ref: uint, using: uint }),
+    18: record({ ref: uint, field: str }),
+  }));
+  const condition = variant((self) => ({
+    0: record({ ref }), 15: record({ ref }),
+    ...Object.fromEntries([1, 2, 5, 6, 7, 8].map((tag) => [tag, record({ ref, value: uint })])),
+    3: record({ ref, value: list(uint) }), 4: record({ ref, value: list(uint) }),
+    ...Object.fromEntries([9, 10, 11].map((tag) => [tag, record({ ref, value: str })])),
+    12: tuple(self, self), 13: tuple(self, self), 14: self,
+  }));
+  const matrix = list(list(i32));
+  const property = variant({
+    0: str, 1: i32, 3: matrix, 25: list(tuple(matrix, condition)),
+    4: i64, 5: f64, 6: bool, 7: uint, 8: list(uint), 10: uint, 11: str,
+    12: list(tuple(u8, str, optional(str))), 14: i64, 15: uint,
+    16: dict(i16, uint), 17: dict(str, str),
+    18: record({ ref, prop_ref: uint, is_default: bool }), 31: record({ ref }),
+    19: action, 21: list(uint), 22: condition, 24: list(uint),
+    26: list(str), 27: list(i32), 28: list(f64), 29: list(bool),
+    30: tuple(str, dict(str, str), dict(str, str), str, u8), 13: constant(undefined),
+  });
+  const message = variant({
+    0: record({ els: list(element), props: list(property), ts: i32 }),
+    1: record({ ref: uint, t: optional(i32) }), 2: action,
+  });
+  while (offset < bytes.length) {
+    end = bytes.length;
+    const length = view.getUint32(take(4), true);
+    end = offset + length;
+    if (end > bytes.length) throw new Error("truncated jetfuel frame");
+    messages.push(message());
+    if (offset !== end) throw new Error("unexpected jetfuel frame data");
+  }
+  return { messages, strings };
+}