npm - emusks - Versions diffs - 2.3.5 → 2.3.7 - Mend

emusks 2.3.5 → 2.3.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/package.json +1 -1
package/src/castle.js +261 -0
package/src/flow-jetfuel.js +288 -0
package/src/flow.js +2 -2
package/src/helpers/media.js +2 -2
package/src/index.js +5 -1
package/src/scripts/castle-mint-test.js +8 -0
package/src/scripts/login-test.js +28 -0
package/src/scripts/verify-session.js +11 -0
package/src/vendor/castle-sdk.min.js +3 -0

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "emusks",
-  "version": "2.3.5",
+  "version": "2.3.7",
   "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/castle.js ADDED Viewed

@@ -0,0 +1,261 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import vm from "node:vm";
+import { parseHTML } from "linkedom";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const DEFAULT_CASTLE_PK = "pk_AvRa79bHyJSYSQHnRpcVtzyxetSvFerx";
+export const CASTLE_MODULE_ID = "84197";
+const DEFAULT_UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36";
+function pluginArray() {
+  const names = [
+    "PDF Viewer",
+    "Chrome PDF Viewer",
+    "Chromium PDF Viewer",
+    "Microsoft Edge PDF Viewer",
+    "WebKit built-in PDF",
+  ];
+  const arr = names.map((name) => ({
+    name,
+    description: "Portable Document Format",
+    filename: "internal-pdf-viewer",
+    length: 2,
+  }));
+  arr.item = (i) => arr[i] || null;
+  arr.namedItem = (n) => arr.find((p) => p.name === n) || null;
+  arr.refresh = () => {};
+  return arr;
+}
+function mimeTypeArray() {
+  const arr = [
+    { type: "application/pdf", suffixes: "pdf", description: "Portable Document Format" },
+    { type: "text/pdf", suffixes: "pdf", description: "Portable Document Format" },
+  ];
+  arr.item = (i) => arr[i] || null;
+  arr.namedItem = (n) => arr.find((m) => m.type === n) || null;
+  return arr;
+}
+function buildSandbox(userAgent) {
+  const { document } = parseHTML(
+    "<!DOCTYPE html><html><head><title>X</title></head><body></body></html>",
+  );
+  const define = (prop, value) => {
+    try {
+      Object.defineProperty(document, prop, { get: () => value, configurable: true });
+    } catch {}
+  };
+  define("cookie", "");
+  define("readyState", "complete");
+  define("referrer", "https://x.com/");
+  define("visibilityState", "visible");
+  define("hidden", false);
+  document.hasFocus = () => true;
+  const s = {};
+  s.globalThis = s;
+  s.self = s;
+  s.window = s;
+  s.global = s;
+  s.top = s;
+  s.parent = s;
+  s.frames = s;
+  s.name = "";
+  s.closed = false;
+  s.origin = "https://x.com";
+  s.isSecureContext = true;
+  s.document = document;
+  s.navigator = {
+    userAgent,
+    appVersion: userAgent.replace("Mozilla/", ""),
+    appName: "Netscape",
+    appCodeName: "Mozilla",
+    platform: "MacIntel",
+    vendor: "Google Inc.",
+    vendorSub: "",
+    product: "Gecko",
+    productSub: "20030107",
+    language: "en-US",
+    languages: ["en-US", "en"],
+    hardwareConcurrency: 10,
+    deviceMemory: 8,
+    maxTouchPoints: 0,
+    cookieEnabled: true,
+    onLine: true,
+    doNotTrack: null,
+    webdriver: false,
+    pdfViewerEnabled: true,
+    plugins: pluginArray(),
+    mimeTypes: mimeTypeArray(),
+    userAgentData: {
+      brands: [
+        { brand: "Not(A:Brand", version: "8" },
+        { brand: "Chromium", version: "144" },
+        { brand: "Google Chrome", version: "144" },
+      ],
+      mobile: false,
+      platform: "macOS",
+      getHighEntropyValues: async () => ({
+        platform: "macOS",
+        platformVersion: "15.0.0",
+        architecture: "arm",
+        model: "",
+        uaFullVersion: "144.0.0.0",
+        bitness: "64",
+      }),
+    },
+    permissions: { query: async () => ({ state: "prompt" }) },
+    mediaDevices: { enumerateDevices: async () => [] },
+    connection: { effectiveType: "4g", rtt: 50, downlink: 10, saveData: false },
+    sendBeacon: () => true,
+    javaEnabled: () => false,
+  };
+  s.screen = {
+    width: 1512,
+    height: 982,
+    availWidth: 1512,
+    availHeight: 944,
+    colorDepth: 30,
+    pixelDepth: 30,
+    availLeft: 0,
+    availTop: 0,
+    orientation: { type: "landscape-primary", angle: 0 },
+  };
+  s.location = {
+    href: "https://x.com/i/flow/login",
+    protocol: "https:",
+    host: "x.com",
+    hostname: "x.com",
+    origin: "https://x.com",
+    pathname: "/i/flow/login",
+    search: "",
+    hash: "",
+  };
+  s.history = { length: 2, state: null, pushState: () => {}, replaceState: () => {} };
+  const store = {};
+  s.localStorage = {
+    getItem: (k) => (k in store ? store[k] : null),
+    setItem: (k, v) => {
+      store[k] = String(v);
+    },
+    removeItem: (k) => {
+      delete store[k];
+    },
+    clear: () => {
+      for (const k in store) delete store[k];
+    },
+    key: (i) => Object.keys(store)[i] ?? null,
+    get length() {
+      return Object.keys(store).length;
+    },
+  };
+  s.sessionStorage = { getItem: () => null, setItem: () => {}, removeItem: () => {}, clear: () => {} };
+  s.innerWidth = 1512;
+  s.innerHeight = 850;
+  s.outerWidth = 1512;
+  s.outerHeight = 944;
+  s.screenX = 0;
+  s.screenY = 0;
+  s.pageXOffset = 0;
+  s.pageYOffset = 0;
+  s.devicePixelRatio = 2;
+  s.chrome = { app: { isInstalled: false }, runtime: {}, csi: () => ({}), loadTimes: () => ({}) };
+  s.Intl = Intl;
+  s.matchMedia = (q) => ({
+    matches: false,
+    media: q,
+    addEventListener: () => {},
+    removeEventListener: () => {},
+    addListener: () => {},
+    removeListener: () => {},
+  });
+  s.addEventListener = () => {};
+  s.removeEventListener = () => {};
+  s.dispatchEvent = () => true;
+  s.requestAnimationFrame = (cb) => setTimeout(() => cb(performance.now()), 0);
+  s.cancelAnimationFrame = (id) => clearTimeout(id);
+  s.requestIdleCallback = (cb) => setTimeout(() => cb({ timeRemaining: () => 50, didTimeout: false }), 0);
+  s.cancelIdleCallback = (id) => clearTimeout(id);
+  s.setTimeout = setTimeout;
+  s.clearTimeout = clearTimeout;
+  s.setInterval = setInterval;
+  s.clearInterval = clearInterval;
+  s.setImmediate = setImmediate;
+  s.queueMicrotask = queueMicrotask;
+  s.performance = performance;
+  s.crypto = globalThis.crypto;
+  s.btoa = (str) => Buffer.from(str, "binary").toString("base64");
+  s.atob = (str) => Buffer.from(str, "base64").toString("binary");
+  s.TextEncoder = TextEncoder;
+  s.TextDecoder = TextDecoder;
+  s.console = { log: () => {}, warn: () => {}, error: () => {}, info: () => {}, debug: () => {} };
+  s.Image = class {
+    set src(_v) {}
+  };
+  s.XMLHttpRequest = class {
+    open() {}
+    setRequestHeader() {}
+    send() {}
+    addEventListener() {}
+  };
+  s.getComputedStyle = () => ({ getPropertyValue: () => "" });
+  return s;
+}
+export function createCastleMinter(opts = {}) {
+  const {
+    pk = DEFAULT_CASTLE_PK,
+    userAgent = DEFAULT_UA,
+    sdkPath = join(HERE, "vendor", "castle-sdk.min.js"),
+    sdkSource,
+  } = opts;
+  const src = sdkSource ?? readFileSync(sdkPath, "utf8");
+  const sandbox = buildSandbox(userAgent);
+  let factory = null;
+  sandbox.webpackChunk_twitter_responsive_web = {
+    push: (entry) => {
+      const modules = entry?.[1];
+      if (modules && modules[CASTLE_MODULE_ID]) factory = modules[CASTLE_MODULE_ID];
+    },
+  };
+  const ctx = vm.createContext(sandbox);
+  vm.runInContext(src, ctx, { filename: "castle-sdk.min.js" });
+  if (!factory) throw new Error(`castle sdk module ${CASTLE_MODULE_ID} not found (X may have rotated the chunk)`);
+  const moduleObj = { exports: {} };
+  factory(moduleObj, moduleObj.exports);
+  const api = moduleObj.exports;
+  if (typeof api.configure !== "function" || typeof api.createRequestToken !== "function") {
+    throw new Error("castle sdk did not expose configure/createRequestToken (chunk changed)");
+  }
+  const configured = api.configure({ pk });
+  return async function mint() {
+    const instance = await Promise.resolve(configured);
+    const token = instance?.createRequestToken
+      ? await instance.createRequestToken()
+      : await api.createRequestToken();
+    if (!token) throw new Error("castle createRequestToken returned empty");
+    return token;
+  };
+}
+let sharedMinter = null;
+export async function mintCastleToken(opts = {}) {
+  if (!sharedMinter || opts.fresh) sharedMinter = createCastleMinter(opts);
+  return sharedMinter();
+}

package/src/flow-jetfuel.js ADDED Viewed

@@ -0,0 +1,288 @@
+import { ClientTransaction, handleXMigration } from "x-client-transaction-id";
+import { mintCastleToken } from "./castle.js";
+import clients from "./clients.js";
+import getCycleTLS from "./cycletls.js";
+import { decodeJetfuel } from "./parsers/jetfuel.js";
+const GUEST_ACTIVATE_URL = "https://api.x.com/1.1/guest/activate.json";
+const JFAPI_BASE = "https://x.com/i/jfapi";
+const SURFACE = "onboarding/web";
+const UA =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36";
+const MAX_STEPS = 15;
+class CookieSession {
+  constructor(cycleTLS, proxy, timeout) {
+    this.cycleTLS = cycleTLS;
+    this.cookies = {};
+    this.proxy = proxy;
+    this.timeout = timeout;
+  }
+  cookieString() {
+    return Object.entries(this.cookies)
+      .map(([k, v]) => `${k}=${v}`)
+      .join("; ");
+  }
+  eat(res) {
+    const setCookie = res.headers?.["set-cookie"] || res.headers?.["Set-Cookie"];
+    if (!setCookie) return;
+    for (const cookie of Array.isArray(setCookie) ? setCookie : [setCookie]) {
+      const [key, ...rest] = cookie.split(";")[0].split("=");
+      if (rest.length) this.cookies[key.trim()] = rest.join("=").trim();
+    }
+  }
+  async request(url, method, { headers = {}, body, responseType } = {}) {
+    const h = { ...headers };
+    const cookieStr = this.cookieString();
+    if (cookieStr) h.Cookie = cookieStr;
+    const res = await this.cycleTLS(
+      url,
+      {
+        body,
+        ja3: clients.web.fingerprints.ja3,
+        ja4r: clients.web.fingerprints.ja4r,
+        userAgent: UA,
+        headers: h,
+        proxy: this.proxy || undefined,
+        responseType,
+        timeout: this.timeout,
+      },
+      method,
+    );
+    this.eat(res);
+    return res;
+  }
+}
+function jfHeaders(guestToken, tid, theme) {
+  const headers = {
+    authorization: `Bearer ${clients.web.bearer}`,
+    "x-guest-token": guestToken,
+    "x-jf-v": "JP-5",
+    "x-jf-client-theme": theme,
+    "x-twitter-active-user": "yes",
+    "x-twitter-client-language": "en",
+    "accept-language": "en",
+    accept: "*/*",
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    Origin: "https://x.com",
+    Referer: "https://x.com/i/flow/login",
+  };
+  if (tid) headers["x-client-transaction-id"] = tid;
+  return headers;
+}
+async function getGuestToken(session) {
+  const res = await session.request(GUEST_ACTIVATE_URL, "post", {
+    headers: { Authorization: `Bearer ${clients.web.bearer}` },
+  });
+  let body = res.body ?? res.data;
+  if (typeof body === "string") body = JSON.parse(body);
+  if (!body?.guest_token) throw new Error("failed to obtain guest token");
+  return body.guest_token;
+}
+async function toBuffer(res) {
+  if (typeof res.arrayBuffer === "function") return Buffer.from(await res.arrayBuffer());
+  const body = res.body ?? res.data;
+  if (Buffer.isBuffer(body)) return body;
+  if (body && typeof body === "object" && body.data) return Buffer.from(body.data);
+  return Buffer.from(String(body ?? ""), "utf8");
+}
+function decodeStrings(buffer) {
+  try {
+    return decodeJetfuel(buffer).strings || [];
+  } catch {
+    return [];
+  }
+}
+function extractActionIds(strings) {
+  const ids = new Set();
+  for (const s of strings) {
+    const m = String(s).match(/onboarding\/web\/actions\/([a-z0-9_]+)/i);
+    if (m) ids.add(m[1]);
+  }
+  return [...ids];
+}
+function extractServerError(strings) {
+  const idx = strings.findIndex((s) => /^errors?$/i.test(String(s).trim()));
+  if (idx === -1) return null;
+  for (let i = idx + 1; i < strings.length; i++) {
+    const s = String(strings[i]).trim();
+    if (s.length > 8 && /[a-z]\s[a-z]/i.test(s) && !/^error$/i.test(s)) return s;
+  }
+  return null;
+}
+function extractUserId(cookies) {
+  const twid = (cookies.twid || "").replace(/"/g, "");
+  for (const prefix of ["u=", "u%3D"]) {
+    if (twid.includes(prefix)) return twid.split(prefix)[1].split("&")[0].replace(/"/g, "");
+  }
+  return null;
+}
+async function resolve(value, onRequest, type) {
+  if (value != null && value !== "") return value;
+  if (onRequest) {
+    const v = await onRequest(type);
+    if (v != null && v !== "") return v;
+  }
+  throw new Error(
+    `the login flow needs "${type}" but none was provided. pass it directly or handle it in onRequest.`,
+  );
+}
+export default async function flowLoginJetfuel(opts) {
+  const {
+    username,
+    password,
+    email,
+    phone,
+    onRequest,
+    getCastleToken = () => mintCastleToken(),
+    proxy,
+    timeout,
+    theme = "light",
+    debug,
+  } = opts;
+  const log = debug ? (...a) => console.error("[jf-flow]", ...a) : () => {};
+  const identifier = username || email;
+  if (!identifier) throw new Error("username or email is required for login");
+  if (!password) throw new Error("password is required for login");
+  const cycleTLS = await getCycleTLS();
+  const session = new CookieSession(cycleTLS, proxy, timeout);
+  const migrationDoc = await handleXMigration();
+  const transaction = new ClientTransaction(migrationDoc);
+  await transaction.initialize();
+  const tid = (method, path) => transaction.generateTransactionId(method, path);
+  const guestToken = await getGuestToken(session);
+  log("guest token", guestToken);
+  const landingPath = `/i/jfapi/${SURFACE}?mode=login`;
+  const landing = await session.request(`${JFAPI_BASE}/${SURFACE}?mode=login`, "get", {
+    headers: jfHeaders(guestToken, await tid("GET", landingPath), theme),
+    responseType: "arraybuffer",
+  });
+  if (landing.status !== 200) throw new Error(`landing failed: ${landing.status}`);
+  let strings = decodeStrings(await toBuffer(landing));
+  log("landing actions", extractActionIds(strings));
+  const post = async (action, fields) => {
+    const path = `/i/jfapi/${SURFACE}/actions/${action}`;
+    const castle = await getCastleToken(action);
+    const form = new URLSearchParams({ ...fields, $castle_token: castle }).toString();
+    const headers = jfHeaders(guestToken, await tid("POST", path), theme);
+    headers["content-type"] = "application/x-www-form-urlencoded";
+    if (session.cookies.ct0) headers["x-csrf-token"] = session.cookies.ct0;
+    const res = await session.request(`${JFAPI_BASE}/${SURFACE}/actions/${action}`, "post", {
+      headers,
+      body: form,
+      responseType: "arraybuffer",
+    });
+    const buffer = await toBuffer(res);
+    const responseStrings = decodeStrings(buffer);
+    log(`POST ${action} -> ${res.status}`, extractActionIds(responseStrings));
+    if (res.status !== 200) {
+      throw new Error(`action ${action} failed: ${res.status} - ${buffer.toString("utf8").slice(0, 200)}`);
+    }
+    const genericError = responseStrings.find((s) => /something went wrong/i.test(s));
+    if (genericError && responseStrings.length < 6) {
+      throw new Error(
+        `action ${action} rejected ("${genericError}") - usually an invalid or missing $castle_token.`,
+      );
+    }
+    const serverError = extractServerError(responseStrings);
+    if (serverError) {
+      if (/temporarily limited|rate.?limit|try again later/i.test(serverError)) {
+        throw new Error(`login rate-limited by X: "${serverError.trim()}" (back off this account/IP)`);
+      }
+      throw new Error(`action ${action} error: "${serverError.trim()}"`);
+    }
+    return responseStrings;
+  };
+  const sessionTokenFrom = (arr) => {
+    const i = arr.findIndex((s) => /^session_token$/i.test(String(s).trim()));
+    if (i === -1) return null;
+    const v = String(arr[i + 1] || "").trim();
+    return /^[0-9a-f-]{20,}$/i.test(v) ? v : null;
+  };
+  let sessionToken = null;
+  const withSession = (fields) => (sessionToken ? { session_token: sessionToken, ...fields } : fields);
+  strings = await post("begin_login", { username_or_email: identifier });
+  sessionToken = sessionTokenFrom(strings) || sessionToken;
+  let step = 0;
+  while (!session.cookies.auth_token && step < MAX_STEPS) {
+    step++;
+    const lower = strings.map((s) => String(s).toLowerCase());
+    const has = (needle) => lower.some((s) => s.includes(needle));
+    if (has("incorrect") || has("wrong password")) {
+      throw new Error("login denied: the password was incorrect");
+    }
+    if (has("suspend") || has("locked") || has("denied")) {
+      throw new Error("login denied: account locked or suspended");
+    }
+    const wantsPasswordEntry = has("enter your password") || has("login_enter_password");
+    const wantsTwoFactor = has("two_factor") || has("2fa") || has("authentication code");
+    const wantsEmailCode = has("acid") || has("verifycode") || has("verification code") ||
+      (has("verification") && has("code"));
+    const wantsAlternate = has("alternate") || has("login_enter_alternate_identifier");
+    if (wantsTwoFactor) {
+      const code = await resolve(null, onRequest, "two_factor_code");
+      strings = await post("login_enter_two_factor", withSession({ text: code }));
+      sessionToken = sessionTokenFrom(strings) || sessionToken;
+      continue;
+    }
+    if (wantsEmailCode) {
+      const code = await resolve(null, onRequest, "email_code");
+      strings = await post("login_acid", withSession({ text: code }));
+      sessionToken = sessionTokenFrom(strings) || sessionToken;
+      continue;
+    }
+    if (wantsAlternate) {
+      const value = await resolve(email || phone, onRequest, "alternate_identifier");
+      strings = await post("login_enter_alternate_identifier", withSession({ text: value }));
+      sessionToken = sessionTokenFrom(strings) || sessionToken;
+      continue;
+    }
+    if (wantsPasswordEntry || has("password")) {
+      strings = await post("login_enter_password", withSession({ password }));
+      sessionToken = sessionTokenFrom(strings) || sessionToken;
+      continue;
+    }
+    throw new Error(
+      `unhandled jetfuel login step. decoded actions: [${extractActionIds(strings).join(", ")}]. ` +
+        `strings sample: ${JSON.stringify(strings.slice(0, 20))}`,
+    );
+  }
+  if (!session.cookies.auth_token) {
+    throw new Error(`login did not complete after ${step} steps`);
+  }
+  return {
+    authToken: session.cookies.auth_token,
+    csrfToken: session.cookies.ct0 || null,
+    userId: extractUserId(session.cookies),
+    cookies: { ...session.cookies },
+  };
+}

package/src/flow.js CHANGED Viewed

@@ -135,7 +135,7 @@ class CookieSession {
 function getFlowHeaders(guestToken) {
   const headers = {
-    Authorization: `Bearer ${clients.tweetdeck.bearer}`,
+    Authorization: `Bearer ${clients.web.bearer}`,
     "Content-Type": "application/json",
     Accept: "*/*",
     "Accept-Language": "en-US",
@@ -178,7 +178,7 @@ async function makeRequest(session, headers, flowToken, subtaskData) {
 async function getGuestToken(session) {
   const response = await session.post(GUEST_ACTIVATE_URL, {
-    headers: { Authorization: `Bearer ${clients.tweetdeck.bearer}` },
+    headers: { Authorization: `Bearer ${clients.web.bearer}` },
   });
   if (response.status !== 200) {

package/src/helpers/media.js CHANGED Viewed

@@ -219,7 +219,7 @@ export async function create(source, opts = {}) {
     });
   }
-  return { media_id: mediaId, ...finalizeData };
+  return { ...finalizeData, media_id: mediaId };
 }
 export async function createFromUrl(url, opts = {}) {
@@ -274,7 +274,7 @@ export async function createFromUrl(url, opts = {}) {
     });
   }
-  return { media_id: mediaId, ...initData };
+  return { ...initData, media_id: mediaId };
 }
 export async function createMetadata(mediaId, altText, opts = {}) {

package/src/index.js CHANGED Viewed

@@ -2,6 +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 flowLoginJetfuel from "./flow-jetfuel.js";
 import graphql, { GRAPHQL_ENDPOINTS } from "./graphql.js";
 import grokApi from "./grok.js";
 import initHelpers from "./helpers/index.js";
@@ -64,13 +65,16 @@ export default class Emusks {
       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({
+      const runFlow = p.flow === "classic" ? flowLogin : flowLoginJetfuel;
+      const flowResult = await runFlow({
         username: p.username,
         password: p.password,
         email: p.email,
         phone: p.phone,
         onRequest: p.onRequest,
+        getCastleToken: p.getCastleToken,
         proxy: p.proxy,
+        debug: p.debug,
       });
       p = {

package/src/scripts/castle-mint-test.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { mintCastleToken } from "../castle.js";
+const t0 = Date.now();
+const token = await mintCastleToken();
+console.error(`[castle] minted in ${Date.now() - t0}ms`);
+console.error(`[castle] len=${token.length} format=${/^[A-Za-z0-9]+\|/.test(token) ? "ok (<id>|<payload>)" : "unexpected"}`);
+console.error(`[castle] head=${token.slice(0, 24)}`);
+process.exit(0);

package/src/scripts/login-test.js ADDED Viewed

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import flowLoginJetfuel from "../flow-jetfuel.js";
+const CODE_FILE = "/tmp/x-code.txt";
+const pollCode = async (type) => {
+  console.error(`[test] NEED ${type} -> write it to ${CODE_FILE}`);
+  for (let i = 0; i < 90; i++) {
+    if (existsSync(CODE_FILE)) { const c = readFileSync(CODE_FILE, "utf8").trim(); unlinkSync(CODE_FILE); if (c) { console.error(`[test] got ${type}`); return c; } }
+    await new Promise((r) => setTimeout(r, 2000));
+  }
+  throw new Error(`${type} not provided within timeout`);
+};
+try {
+  const r = await flowLoginJetfuel({
+    username: process.env.TEST_USER,
+    password: process.env.TEST_PW,
+    proxy: process.env.PROXY,
+    timeout: 30,
+    debug: true,
+    onRequest: pollCode,
+  });
+  console.error("[test] LOGIN OK userId=", r.userId, "auth_token?", Boolean(r.authToken), "ct0?", Boolean(r.csrfToken));
+  if (process.env.SESSION_OUT) { writeFileSync(process.env.SESSION_OUT, JSON.stringify(r, null, 2), { mode: 0o600 }); console.error("[test] session ->", process.env.SESSION_OUT); }
+} catch (e) {
+  console.error("[test] FAILED:", e.message);
+}
+process.exit(0);

package/src/scripts/verify-session.js ADDED Viewed

@@ -0,0 +1,11 @@
+import { readFileSync } from "node:fs";
+import Emusks from "../index.js";
+const s = JSON.parse(readFileSync(process.env.SESSION_IN || "/tmp/emusks-session.json", "utf8"));
+const client = new Emusks();
+await client.login({ auth_token: s.authToken || s.auth_token, endpoint: "web", transactionIds: true });
+const res = await client.v1_1("get:account/settings", {});
+const body = await res.json();
+console.error("[verify] status", res.status, "| @" + body.screen_name, "| country", body.country_code);
+process.exit(0);