@lazyneoaz/metachat 4.0.6 → 4.0.8

package/dist/index.cjs

@@ -25142,13 +25142,15 @@ function getHeaders(url2, options, ctx, customHeader) {
     headers["priority"] = "u=0, i";
   }
   if (isXhr) {
-    headers["X-Requested-With"] = "XMLHttpRequest";
-    headers["Pragma"] = "no-cache";
-    headers["Cache-Control"] = "no-cache";
+    if (!isGraphQl) {
+      headers["X-Requested-With"] = "XMLHttpRequest";
+      headers["Pragma"] = "no-cache";
+      headers["Cache-Control"] = "no-cache";
+    }
     headers["priority"] = "u=1, i";
   }
   if (isGraphQl) {
-    headers["x-asbd-id"] = "129477";
+    headers["x-asbd-id"] = String(ctx?.asbdId || DEFAULT_ASBD_ID);
     const lsd = ctx?.lsd || ctx?.fb_lsd;
     if (lsd) headers["x-fb-lsd"] = sanitizeHeaderValue2(lsd);
     const friendlyName = customHeader?.["x-fb-friendly-name"] || customHeader?.["X-Fb-Friendly-Name"];
@@ -25219,10 +25221,11 @@ function getFingerprintParams(options) {
     dpr: String(profile.devicePixelRatio)
   };
 }
-var meta;
+var DEFAULT_ASBD_ID, meta;
 var init_headers = __esm({
   "src/utils/headers.ts"() {
     init_user_agents();
+    DEFAULT_ASBD_ID = "359341";
     meta = (prop2) => new RegExp(`<meta property="${prop2}" content="([^"]*)"`);
   }
 });
@@ -75560,9 +75563,13 @@ __export(utils_exports2, {
   NUM_TO_MONTH: () => NUM_TO_MONTH,
   NetworkError: () => NetworkError,
   NotFoundError: () => NotFoundError,
+  PING_GRACE_MS: () => PING_GRACE_MS,
   PermissionError: () => PermissionError,
   RateLimitError: () => RateLimitError,
+  RealtimeHealth: () => RealtimeHealth,
+  RecoverySupervisor: () => RecoverySupervisor,
   SESSION_COOKIE_NAMES: () => SESSION_COOKIE_NAMES,
+  SILENT_WINDOW_MS: () => SILENT_WINDOW_MS,
   TimeoutError: () => TimeoutError,
   ValidationError: () => ValidationError,
   WINDOW_MS: () => WINDOW_MS,
@@ -75587,6 +75594,7 @@ __export(utils_exports2, {
   delay: () => delay2,
   ensureCometTokens: () => ensureCometTokens,
   error: () => error,
+  extractAsbdId: () => extractAsbdId,
   extractAttachmentIds: () => extractAttachmentIds,
   extractCookies: () => extractCookies,
   extractCookiesFromBody: () => extractCookiesFromBody,
@@ -75637,6 +75645,7 @@ __export(utils_exports2, {
   invalidateCometTokens: () => invalidateCometTokens,
   isAuthFailure: () => isAuthFailure,
   isBreakerOpen: () => isBreakerOpen,
+  isLoggedOutDocument: () => isLoggedOutDocument,
   isReadableStream: () => isReadableStream2,
   isStaleTokenError: () => isStaleTokenError,
   json: () => json2,
@@ -75674,6 +75683,8 @@ __export(utils_exports2, {
   setProxy: () => setProxy2,
   sleep: () => sleep,
   startLiveness: () => startLiveness,
+  startRealtimeSupervisor: () => startRealtimeSupervisor,
+  startRecovery: () => startRecovery,
   success: () => success,
   tripBreaker: () => tripBreaker,
   uploadGroupImage: () => uploadGroupImage,
@@ -91030,6 +91041,9 @@ function extractLsd(html3) {
 function extractDtsg(html3) {
   return getFrom3(html3, '["DTSGInitialData",[],{"token":"', '"}') || getFrom3(html3, 'name="fb_dtsg" value="', '"') || (html3.match(/"DTSGInitialData",\[\],\{"token":"([^"]+)"/) || [])[1] || "";
 }
+function extractAsbdId(html3) {
+  return (html3.match(/"asbd_id":(\d+)/) || [])[1] || (html3.match(/x-asbd-id["']?\s*[:=]\s*["']?(\d+)/i) || [])[1] || (html3.match(/"ASBD_ID":(\d+)/) || [])[1] || "";
+}
 function extractSpin(html3) {
   const out = {};
   const spinB = (html3.match(/"__spin_b":"([^"]+)"/) || [])[1];
@@ -91096,6 +91110,8 @@ async function ensureCometTokens(ctx, defaultFuncs, force = false) {
     const spin = extractSpin(html3);
     if (Object.keys(spin).length) ctx.__spin = { ...ctx.__spin || {}, ...spin };
     if (spin.__rev) ctx.revision = spin.__rev;
+    const asbd = extractAsbdId(html3);
+    if (asbd) ctx.asbdId = asbd;
     ctx.lsd = lsd;
     ctx.fb_dtsg = dtsg;
     ctx.jazoest = recomputeJazoest(dtsg);
@@ -91366,6 +91382,13 @@ function isAuthFailure(value) {
   }
   return false;
 }
+function isLoggedOutDocument(html3) {
+  if (typeof html3 !== "string" || html3.length < 200) return false;
+  if (!/<html/i.test(html3)) return false;
+  const hasAuthedTokens = /DTSGInitialData|"LSD",\[\]/.test(html3);
+  const looksLikeLogin = /name="(?:email|pass)"|id="email"|"login_form"|LoginForm|login_form/i.test(html3) || /Continue as |Use another profile|Create new account/i.test(html3) || /You must log in to continue|Please log in|log in to continue/i.test(html3);
+  return looksLikeLogin && !hasAuthedTokens;
+}
 async function withSessionRetry(ctx, defaultFuncs, operation, options = {}) {
   const attempts = Math.max(1, options.attempts ?? 2);
   let lastError;
@@ -91472,6 +91495,8 @@ async function warmUpSession(ctx, getter, options = {}) {
           const spin = extractSpin(html3);
           if (Object.keys(spin).length) ctx.__spin = { ...ctx.__spin || {}, ...spin };
           if (spin.__rev) ctx.revision = spin.__rev;
+          const asbd = extractAsbdId(html3);
+          if (asbd) ctx.asbdId = asbd;
           tokensSeeded = true;
         }
       } else if (url2.includes("/messages")) {
@@ -91570,6 +91595,339 @@ async function awaitProactiveSlot(ctx, maxWaitMs = 15 * 60 * 1e3) {
   return false;
 }
 
+// src/utils/recovery.ts
+init_pacing();
+init_safety();
+var DEFAULTS = {
+  intervalMs: 10 * 60 * 1e3,
+  failureThreshold: 3,
+  maxRecoveries: 5
+};
+function randJitter(base, spread3 = 0.3) {
+  return Math.floor(base * (1 - spread3 / 2 + Math.random() * spread3));
+}
+var RecoverySupervisor = class {
+  constructor(runtime, options = {}) {
+    this.timer = null;
+    this.stopped = true;
+    this.running = false;
+    this.runtime = runtime;
+    this.opts = {
+      intervalMs: options.intervalMs ?? DEFAULTS.intervalMs,
+      failureThreshold: options.failureThreshold ?? DEFAULTS.failureThreshold,
+      maxRecoveries: options.maxRecoveries ?? DEFAULTS.maxRecoveries,
+      noRelogin: options.noRelogin ?? false
+    };
+    this.backoffMs = this.opts.intervalMs;
+    this.state = {
+      phase: "healthy",
+      checks: 0,
+      consecutiveFailures: 0,
+      healCount: 0,
+      attempts: 0,
+      reloginCount: 0,
+      givenUp: 0,
+      lastHealthyAt: Date.now(),
+      nextCheckMs: 0,
+      canRelogin: typeof runtime.relogin === "function" && !this.opts.noRelogin && (runtime.canRelogin !== void 0 ? runtime.canRelogin : true)
+    };
+  }
+  /** A point-in-time copy of the supervisor state. */
+  snapshot() {
+    return { ...this.state, nextCheckMs: Math.max(0, this.nextCheckAt() - Date.now()) };
+  }
+  isRunning() {
+    return !this.stopped;
+  }
+  /** Start the supervisor. Idempotent. */
+  start() {
+    if (!this.stopped) return;
+    this.stopped = false;
+    if (this.state.phase === "stopped") this.state.phase = "healthy";
+    this.startTimer(false);
+    this.emit("check", "recovery supervisor started");
+  }
+  /** Stop the supervisor and clear any pending timer. */
+  stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.state.phase = "stopped";
+    this.emit("stopped", "recovery supervisor stopped");
+  }
+  /**
+   * Run one health check immediately (used by tests and by `checkNow()`).
+   * Returns the resulting state. Never throws.
+   */
+  async checkNow() {
+    if (this.running) return this.snapshot();
+    this.running = true;
+    try {
+      await this.runOnce();
+    } catch {
+    } finally {
+      this.running = false;
+    }
+    return this.snapshot();
+  }
+  nextCheckAt() {
+    return this.state.nextCheckMs && this.timer ? Date.now() + this.state.nextCheckMs : 0;
+  }
+  startTimer(delayOverride) {
+    if (this.stopped) return;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const delay3 = delayOverride === false ? this.backoffMs : delayOverride ?? this.backoffMs;
+    const jittered = randJitter(delay3);
+    this.state.nextCheckMs = jittered;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.state.nextCheckMs = 0;
+      void this.checkNow().finally(() => {
+        if (!this.stopped) this.startTimer();
+      });
+    }, jittered);
+    if (this.timer && typeof this.timer.unref === "function") this.timer.unref();
+  }
+  async runOnce() {
+    this.state.checks += 1;
+    this.emit("check", `health check #${this.state.checks}`);
+    let healthy = this.runtime.isAuthenticated();
+    if (healthy && this.runtime.probeLiveness) {
+      try {
+        healthy = await this.runtime.probeLiveness();
+      } catch {
+        healthy = true;
+      }
+    }
+    if (healthy) {
+      this.markHealthy("session authenticated");
+      return;
+    }
+    this.state.consecutiveFailures += 1;
+    this.state.phase = "refreshing";
+    this.emit("unhealthy", `unauthenticated (${this.state.consecutiveFailures}/${this.opts.failureThreshold})`);
+    if (this.state.consecutiveFailures < this.opts.failureThreshold) {
+      return;
+    }
+    if (isBreakerOpen(this.runtime.ctx)) {
+      this.state.phase = "cooling";
+      this.emit("cooling", "safety breaker open; delaying recovery");
+      return;
+    }
+    if (this.state.attempts >= this.opts.maxRecoveries) {
+      this.state.phase = "cooling";
+      this.state.givenUp += 1;
+      this.emit("gave-up", "recovery budget exhausted");
+      return;
+    }
+    this.state.attempts += 1;
+    let healed = false;
+    try {
+      healed = await this.runtime.refresh();
+    } catch {
+      healed = false;
+    }
+    if (healed && this.runtime.isAuthenticated()) {
+      this.state.healCount += 1;
+      this.markHealthy("cookie refresh restored the session");
+      this.afterRecovery();
+      return;
+    }
+    if (!this.state.canRelogin || !this.runtime.relogin) {
+      this.state.phase = "cooling";
+      this.state.givenUp += 1;
+      this.emit(
+        "gave-up",
+        "session unauthenticated and no credentials available for re-login; provide email+password or a fresh appState"
+      );
+      return;
+    }
+    this.state.phase = "relogin";
+    let fresh = null;
+    try {
+      fresh = await this.runtime.relogin();
+    } catch {
+      fresh = null;
+    }
+    if (Array.isArray(fresh) && fresh.length > 0) {
+      this.state.reloginCount += 1;
+      try {
+        this.runtime.persistAppState?.(fresh);
+      } catch {
+      }
+      this.markHealthy("credential re-login succeeded");
+      this.afterRecovery();
+      return;
+    }
+    this.state.phase = "cooling";
+    this.state.givenUp += 1;
+    this.emit("gave-up", "credential re-login did not return a fresh session");
+  }
+  markHealthy(detail) {
+    this.state.phase = "healthy";
+    this.state.consecutiveFailures = 0;
+    this.state.lastHealthyAt = Date.now();
+    this.state.lastDetail = detail;
+    this.backoffMs = this.opts.intervalMs;
+    this.emit("healed", detail);
+  }
+  afterRecovery() {
+    try {
+      this.runtime.restartMqtt?.();
+    } catch {
+    }
+  }
+  emit(type, detail) {
+    if (!this.runtime.onEvent) return;
+    try {
+      this.runtime.onEvent({ type, detail, state: this.snapshot() });
+    } catch {
+    }
+  }
+};
+function startRecovery(ctx, runtime, options = {}) {
+  if (ctx.__recovery && typeof ctx.__recovery.stop === "function") {
+    try {
+      ctx.__recovery.stop();
+    } catch {
+    }
+  }
+  const supervisor = new RecoverySupervisor(runtime, options);
+  ctx.__recovery = supervisor;
+  supervisor.start();
+  return supervisor;
+}
+
+// src/utils/realtime-health.ts
+init_pacing();
+var SILENT_WINDOW_MS = 6 * 60 * 1e3;
+var PING_GRACE_MS = 45 * 1e3;
+var RealtimeHealth = class {
+  constructor(now = () => Date.now()) {
+    this.now = now;
+    this.frames = 0;
+    this.lastFrameAt = 0;
+    this.connectedAt = 0;
+    this.probes = 0;
+    this.forcedReconnects = 0;
+    this.lastPingAt = 0;
+    this.startedAt = Date.now();
+    this.startedAt = this.now();
+  }
+  /** Record any inbound frame (message, pong, anything from the broker). */
+  noteFrame() {
+    this.frames += 1;
+    this.lastFrameAt = this.now();
+  }
+  /** Record a successful connect. */
+  noteConnected() {
+    this.connectedAt = this.now();
+    this.lastFrameAt = this.now();
+  }
+  /** Record that the transport reports itself disconnected. */
+  noteDisconnected() {
+    this.lastFrameAt = 0;
+  }
+  /** Record an active ping being sent. */
+  notePing() {
+    this.lastPingAt = this.now();
+  }
+  sinceLastFrame() {
+    const base = this.lastFrameAt || this.connectedAt || this.startedAt;
+    return this.now() - base;
+  }
+  /**
+   * Decide what to do about the current socket.
+   *
+   * - `disconnected` — the transport already knows it is down; reconnect.
+   * - `dead` — connected on paper, silent past the window, and a ping raised no
+   *   traffic within the grace period; reconnect.
+   * - `suspect` — silent past the window but a ping was only just sent; wait.
+   * - `quiet` — silent but inside the window; normal.
+   * - `healthy` — recent traffic.
+   */
+  verdict(connected) {
+    if (!connected) return "disconnected";
+    const silent = this.sinceLastFrame();
+    if (silent < SILENT_WINDOW_MS / 2) return "healthy";
+    if (silent < SILENT_WINDOW_MS) return "quiet";
+    if (this.lastPingAt && this.now() - this.lastPingAt < PING_GRACE_MS) return "suspect";
+    return "dead";
+  }
+  /** A snapshot for diagnostics. */
+  state(connected) {
+    return {
+      connected,
+      sinceLastFrameMs: this.sinceLastFrame(),
+      frames: this.frames,
+      probes: this.probes,
+      forcedReconnects: this.forcedReconnects,
+      verdict: this.verdict(connected)
+    };
+  }
+  noteProbe() {
+    this.probes += 1;
+  }
+  noteForcedReconnect() {
+    this.forcedReconnects += 1;
+  }
+};
+function startRealtimeSupervisor(options) {
+  const health = new RealtimeHealth();
+  const interval = options.intervalMs ?? 3 * 60 * 1e3;
+  let stopped = false;
+  let timer = null;
+  const evaluate = () => {
+    const connected = options.isConnected();
+    const verdict = health.verdict(connected);
+    health.noteProbe();
+    if (verdict === "dead") {
+      const pingSent = options.ping ? options.ping() : false;
+      if (pingSent) {
+        health.notePing();
+      } else {
+        health.noteForcedReconnect();
+        options.reconnect("realtime socket silent and unpinnable");
+      }
+    }
+    const state = health.state(connected);
+    try {
+      options.onVerdict?.(state);
+    } catch {
+    }
+    return state;
+  };
+  const schedule = () => {
+    if (stopped) return;
+    timer = setTimeout(
+      () => {
+        timer = null;
+        evaluate();
+        schedule();
+      },
+      Math.max(1e3, humanDelay(interval, interval * 0.3))
+    );
+    if (timer && typeof timer.unref === "function") timer.unref();
+  };
+  schedule();
+  return {
+    health,
+    checkNow: evaluate,
+    stop: () => {
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+}
+
 // src/utils/index.ts
 async function json2(url2, jar2, qs2, options, ctx, customHeader) {
   try {
@@ -91787,6 +92145,7 @@ async function buildAPI(html3, jar2, netData, globalOptions, fbLinkFunc, errorRe
   const lsd = lsdConfig && lsdConfig.token || extractLsd(html3) || void 0;
   const spin = extractSpin(html3);
   const revision = spin.__rev || getFrom(html3, 'revision":', ",").trim();
+  const asbdId = extractAsbdId(html3) || void 0;
   const clientIDData = findConfig("MqttWebDeviceID");
   const clientID = clientIDData ? clientIDData.clientID : void 0;
   const mqttConfigData = findConfig("MqttWebConfig");
@@ -91828,7 +92187,8 @@ async function buildAPI(html3, jar2, netData, globalOptions, fbLinkFunc, errorRe
     ...dtsgResult,
     ...lsd ? { lsd } : {},
     ...Object.keys(spin).length ? { __spin: spin } : {},
-    ...revision ? { revision } : {}
+    ...revision ? { revision } : {},
+    ...asbdId ? { asbdId } : {}
   };
   if (lsd && dtsg) {
     ctx.__cometTokens = { lsd, fb_dtsg: dtsg, fetchedAt: Date.now(), failures: 0 };
@@ -91837,8 +92197,95 @@ async function buildAPI(html3, jar2, netData, globalOptions, fbLinkFunc, errorRe
   return [ctx, defaultFuncs, {}];
 }
 
-// src/core/models/loginHelper.ts
+// src/core/models/acquireCookies.ts
 init_axios2();
+function cookieStringFromObject(cookie, index3) {
+  const name = cookie && (cookie.name || cookie.key);
+  if (!name || cookie.value === void 0 || cookie.value === null) {
+    throw new Error(`Invalid appState cookie at index ${index3}.`);
+  }
+  return formatAppStateCookie(cookie);
+}
+function writeCookie(jar2, cookieString) {
+  const normalized = cookieString.replace(/;\s*domain=facebook\.com/i, "; domain=.facebook.com").replace(/;\s*domain=messenger\.com/i, "; domain=.messenger.com");
+  const str = /(^|;)\s*domain=/i.test(normalized) ? normalized : `${normalized}; domain=.facebook.com; path=/; Secure; SameSite=None`;
+  try {
+    jar2.setCookieSync(str, "https://facebook.com");
+    return true;
+  } catch {
+    try {
+      jar2.setCookieSync(
+        `${normalized}; domain=.facebook.com; path=/; Secure; SameSite=None`,
+        "https://www.facebook.com"
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function acquireCookies(jar2, credentials, globalOptions) {
+  const appState = credentials.appState;
+  if (Array.isArray(appState)) {
+    let loaded = 0;
+    appState.forEach((cookie, index3) => {
+      const str = cookieStringFromObject(cookie, index3);
+      if (str.indexOf("=") <= 0) throw new Error(`Invalid appState cookie at index ${index3}.`);
+      if (writeCookie(jar2, str)) loaded++;
+    });
+    return { source: "appState", loaded };
+  }
+  if (typeof appState === "string") {
+    const parts = appState.split(";").map((s) => s.trim()).filter(Boolean);
+    let loaded = 0;
+    parts.forEach((str, index3) => {
+      if (str.indexOf("=") <= 0) throw new Error(`Invalid appState cookie at index ${index3}.`);
+      if (writeCookie(jar2, str)) loaded++;
+    });
+    return { source: "appStateString", loaded };
+  }
+  if (credentials.email && credentials.password) {
+    const url2 = "https://api.facebook.com/method/auth.login";
+    const params = {
+      access_token: "350685531728|62f8ce9f74b12f84c123cc23437a4a32",
+      format: "json",
+      sdk_version: 2,
+      email: credentials.email,
+      locale: "en_US",
+      password: credentials.password,
+      generate_session_cookies: 1,
+      sig: "c1c640010993db92e5afd11634ced864"
+    };
+    const xurl = `${url2}?${qs__default.default.stringify(params)}`;
+    try {
+      const legacyHeaders = getHeaders(url2, globalOptions, null, {
+        "Content-Type": "application/x-www-form-urlencoded"
+      });
+      const resp = await axios_default.get(xurl, {
+        headers: legacyHeaders,
+        timeout: 6e4,
+        validateStatus: (status) => status >= 200 && status < 600
+      });
+      if (resp.status !== 200) throw new Error("Wrong password / email");
+      const sessionCookies = resp.data["session_cookies"] || [];
+      if (!sessionCookies.length) throw new Error("No session cookies returned");
+      let loaded = 0;
+      for (const c of sessionCookies) {
+        const str = `${c.name}=${c.value}; domain=.facebook.com; path=/; Secure; SameSite=None`;
+        try {
+          jar2.setCookieSync(str, "https://facebook.com");
+          loaded++;
+        } catch {
+        }
+      }
+      if (loaded === 0) throw new Error("No session cookies could be stored");
+      return { source: "credentials", loaded };
+    } catch (e) {
+      throw new Error(e && e.message ? e.message : "Wrong password / email");
+    }
+  }
+  throw new Error("No cookie or credentials found. Please provide cookies or credentials.");
+}
 
 // src/deltas/apis/extra/addExternalModule.ts
 function addExternalModule_default(defaultFuncs, api, ctx) {
@@ -100439,7 +100886,9 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
     attempts: 0,
     delay: MQTT_CONFIG.INITIAL_RETRY_DELAY,
     throttleDelay: MQTT_CONFIG.THROTTLE_DELAY,
-    generation: 0
+    generation: 0,
+    health: null,
+    healthSupervisor: null
   };
   const log2 = (...args) => log(...args);
   function clearReconnectTimer() {
@@ -100453,6 +100902,13 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
       clearInterval(lifecycle.presenceInterval);
       lifecycle.presenceInterval = null;
     }
+    if (lifecycle.healthSupervisor) {
+      try {
+        lifecycle.healthSupervisor.stop();
+      } catch (_3) {
+      }
+      lifecycle.healthSupervisor = null;
+    }
     clearReconnectTimer();
   }
   function destroyClient() {
@@ -100580,6 +101036,8 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
       });
       lifecycle.client = client2;
       ctx.mqttClient = client2;
+      const health = new RealtimeHealth();
+      lifecycle.health = health;
       let connected = false;
       let closing = false;
       let throttled = false;
@@ -100599,12 +101057,14 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
         if (generation !== lifecycle.generation) return;
         connected = false;
         ctx.mqttConnected = false;
+        health.noteDisconnected();
       });
       client2.on("close", () => {
         if (generation !== lifecycle.generation) return;
         if (connected) log2("MQTT connection closed.");
         connected = false;
         ctx.mqttConnected = false;
+        health.noteDisconnected();
         if (closing) return;
         closing = true;
         if (authFailure) {
@@ -100622,6 +101082,7 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
       client2.on("connect", () => {
         if (generation !== lifecycle.generation) return;
         connected = true;
+        health.noteConnected();
         client2.subscribe(MQTT_TOPICS, (subErr) => {
           if (subErr) {
             error("Failed to subscribe to MQTT topics:", subErr);
@@ -100658,6 +101119,49 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
           ctx.mqttConnected = true;
           ctx.lastMqttError = null;
           resetBackoff();
+          if (lifecycle.healthSupervisor) {
+            try {
+              lifecycle.healthSupervisor.stop();
+            } catch (_3) {
+            }
+          }
+          lifecycle.healthSupervisor = startRealtimeSupervisor({
+            isConnected: () => generation === lifecycle.generation && client2.connected,
+            reconnect: (reason) => {
+              if (generation !== lifecycle.generation) return;
+              if (lifecycle.stopped || ctx.loggedIn === false) return;
+              log2(`MQTT ${reason}; recycling the socket`);
+              try {
+                client2.end(true);
+              } catch (_3) {
+              }
+              const gen = generation;
+              setTimeout(() => {
+                if (gen !== lifecycle.generation) return;
+                if (lifecycle.stopped || ctx.loggedIn === false) return;
+                if (lifecycle.client && lifecycle.client.connected) return;
+                if (lifecycle.reconnectTimer) return;
+                scheduleReconnect("realtime socket recycled");
+              }, 5e3).unref?.();
+            },
+            ping: () => {
+              try {
+                client2.ping();
+                return true;
+              } catch {
+                return false;
+              }
+            },
+            onVerdict: (state) => {
+              if (state.verdict === "dead") {
+                warn(
+                  "MQTT health",
+                  `silent for ${Math.round(state.sinceLastFrameMs / 1e3)}s; probing`
+                );
+              }
+            }
+          });
+          ctx.__mqttHealth = () => lifecycle.health ? lifecycle.health.state(generation === lifecycle.generation && !!client2.connected) : null;
           api.getBotInitialData().then((botData) => {
             if (botData) {
               log(`Logged in as: ${botData.name || "Facebook User"} (${botData.uid || ctx.userID})`);
@@ -100668,6 +101172,7 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
       });
       client2.on("message", async (topic, message, _packet) => {
         try {
+          health.noteFrame();
           ctx.lastMessageTime = Date.now();
           ctx.messageCount = (ctx.messageCount || 0) + 1;
           const jsonMessage = JSON.parse(message.toString());
@@ -100753,6 +101258,16 @@ var listenMqtt_default = (defaultFuncs, api, ctx) => {
         this.stop();
         if (typeof cb === "function") cb();
       }
+      /** Live connection-health snapshot, for diagnostics/alerting. */
+      getHealth() {
+        if (!lifecycle.health) return null;
+        const connected = !lifecycle.stopped && !!lifecycle.client && !!lifecycle.client.connected;
+        return lifecycle.health.state(connected);
+      }
+      /** Is this listener currently stopped? */
+      isStopped() {
+        return lifecycle.stopped;
+      }
     }
     const msgEmitter = new MessageEmitter();
     lifecycle.stopped = false;
@@ -100921,76 +101436,8 @@ async function loginHelper(credentials, globalOptions, callback, setOptionsFunc,
     const jar2 = getJar();
     log("Logging in...");
     const appState = credentials.appState;
-    if (appState) {
-      let cookieStrings = [];
-      if (Array.isArray(appState)) {
-        cookieStrings = appState.map((c, index3) => {
-          const name = c && (c.name || c.key);
-          if (!name || c.value === void 0 || c.value === null) {
-            throw new Error(`Invalid appState cookie at index ${index3}.`);
-          }
-          return formatAppStateCookie(c);
-        });
-      } else if (typeof appState === "string") {
-        cookieStrings = appState.split(";").map((s) => s.trim()).filter(Boolean);
-      } else {
-        throw new Error(
-          "Invalid appState format. Please provide an array of cookie objects or a cookie string."
-        );
-      }
-      cookieStrings.forEach((cookieString, index3) => {
-        if (cookieString.indexOf("=") <= 0) {
-          throw new Error(`Invalid appState cookie at index ${index3}.`);
-        }
-        const normalized = cookieString.replace(/;\s*domain=facebook\.com/i, "; domain=.facebook.com").replace(/;\s*domain=messenger\.com/i, "; domain=.messenger.com");
-        const str = /(^|;)\s*domain=/i.test(normalized) ? normalized : `${normalized}; domain=.facebook.com; path=/; Secure; SameSite=None`;
-        try {
-          jar2.setCookieSync(str, "https://facebook.com");
-        } catch {
-          try {
-            jar2.setCookieSync(`${normalized}; domain=.facebook.com; path=/; Secure; SameSite=None`, "https://www.facebook.com");
-          } catch {
-          }
-        }
-      });
-    } else if (credentials.email && credentials.password) {
-      const url2 = "https://api.facebook.com/method/auth.login";
-      const params = {
-        access_token: "350685531728|62f8ce9f74b12f84c123cc23437a4a32",
-        format: "json",
-        sdk_version: 2,
-        email: credentials.email,
-        locale: "en_US",
-        password: credentials.password,
-        generate_session_cookies: 1,
-        sig: "c1c640010993db92e5afd11634ced864"
-      };
-      const query = qs__default.default.stringify(params);
-      const xurl = `${url2}?${query}`;
-      try {
-        const legacyHeaders = getHeaders(
-          url2,
-          globalOptions,
-          null,
-          { "Content-Type": "application/x-www-form-urlencoded" }
-        );
-        const resp2 = await axios_default.get(xurl, {
-          headers: legacyHeaders,
-          timeout: 6e4,
-          validateStatus: (status) => status >= 200 && status < 600
-        });
-        if (resp2.status !== 200) {
-          throw new Error("Wrong password / email");
-        }
-        const cstrs = resp2.data["session_cookies"].map((c) => `${c.name}=${c.value}`);
-        cstrs.forEach((cstr) => {
-          const domain = ".facebook.com";
-          const str = `${cstr}; domain=${domain}; path=/; Secure; SameSite=None`;
-          jar2.setCookieSync(str, "https://facebook.com");
-        });
-      } catch (e) {
-        throw new Error("Wrong password / email");
-      }
+    if (appState || credentials.email && credentials.password) {
+      await acquireCookies(jar2, credentials, globalOptions);
     } else {
       throw new Error("No cookie or credentials found. Please provide cookies or credentials.");
     }
@@ -101129,6 +101576,81 @@ async function loginHelper(credentials, globalOptions, callback, setOptionsFunc,
       }
     }
     ctx.__stopCookieKeepAlive = scheduleSessionKeepAlive(ctx, defaultFuncs, 15 * 60 * 1e3);
+    ctx.__credentials = {
+      email: credentials.email,
+      password: credentials.password
+    };
+    ctx.__loginGlobalOptions = globalOptions;
+    ctx.__persistPath = globalOptions.appStatePath;
+    if (globalOptions.recovery !== false) {
+      const recoveryOptions = typeof globalOptions.recovery === "object" ? globalOptions.recovery : {};
+      const supervisor = startRecovery(
+        ctx,
+        {
+          ctx,
+          isAuthenticated: () => hasAuthenticatedSession(ctx.jar),
+          probeLiveness: async () => {
+            try {
+              const res = await defaultFuncs.get(
+                "https://www.facebook.com/",
+                ctx.jar,
+                null,
+                ctx.globalOptions,
+                { noRef: true }
+              );
+              const html3 = typeof res === "string" ? res : res && res.body;
+              if (typeof html3 !== "string" || !html3) return true;
+              return !isLoggedOutDocument(html3);
+            } catch {
+              return true;
+            }
+          },
+          refresh: () => repairSession(ctx, defaultFuncs),
+          canRelogin: Boolean(credentials.email && credentials.password),
+          relogin: async () => {
+            if (!credentials.email || !credentials.password) return null;
+            await sleep(retryDelay(0, 2e3, 15e3));
+            await acquireCookies(ctx.jar, credentials, globalOptions);
+            await repairSession(ctx, defaultFuncs);
+            if (!hasAuthenticatedSession(ctx.jar)) return null;
+            return getAppState(ctx.jar);
+          },
+          persistAppState: (state) => {
+            const path2 = globalOptions.appStatePath;
+            if (!path2) return;
+            try {
+              const fs2 = __require("fs");
+              fs2.writeFileSync(path2, JSON.stringify(state, null, 2));
+              log(`Recovery: refreshed appState written to ${path2}`);
+            } catch (persistError) {
+              warn("Recovery: could not persist appState:", persistError?.message);
+            }
+          },
+          restartMqtt: () => {
+            try {
+              if (typeof ctx.__restartMqtt === "function") {
+                ctx.__restartMqtt();
+              } else if (typeof ctx.reconnectMqtt === "function" && activeListener) {
+                void ctx.reconnectMqtt();
+              }
+            } catch {
+            }
+          },
+          onEvent: (event) => {
+            if (event.type === "gave-up") {
+              warn("Recovery", event.detail);
+            } else if (event.type === "relogin" || event.type === "healed") {
+              log(`Recovery: ${event.detail}`);
+            }
+          }
+        },
+        recoveryOptions
+      );
+      api.getRecoveryState = () => supervisor.snapshot();
+      api.checkRecoveryNow = () => supervisor.checkNow();
+      api.stopRecovery = () => supervisor.stop();
+      api.startRecovery = () => supervisor.start();
+    }
     if (globalOptions.liveness !== false) {
       const liveness = startLiveness(ctx, {
         foregroundPing: () => log("Session active"),
@@ -101311,6 +101833,11 @@ lodash/lodash.js:
    *)
 */
 
+exports.PING_GRACE_MS = PING_GRACE_MS;
+exports.RealtimeHealth = RealtimeHealth;
+exports.RecoverySupervisor = RecoverySupervisor;
+exports.SILENT_WINDOW_MS = SILENT_WINDOW_MS;
+exports.acquireCookies = acquireCookies;
 exports.applySetCookie = applySetCookie;
 exports.awaitProactiveSlot = awaitProactiveSlot;
 exports.canActProactively = canActProactively;
@@ -101330,6 +101857,7 @@ exports.humanDelay = humanDelay;
 exports.invalidateCometTokens = invalidateCometTokens;
 exports.isAuthFailure = isAuthFailure;
 exports.isBreakerOpen = isBreakerOpen;
+exports.isLoggedOutDocument = isLoggedOutDocument;
 exports.isStaleTokenError = isStaleTokenError;
 exports.login = login;
 exports.missingSessionCookies = missingSessionCookies;
@@ -101350,6 +101878,8 @@ exports.retryDelay = retryDelay;
 exports.safetySnapshot = safetySnapshot;
 exports.sleep = sleep;
 exports.startLiveness = startLiveness;
+exports.startRealtimeSupervisor = startRealtimeSupervisor;
+exports.startRecovery = startRecovery;
 exports.tripBreaker = tripBreaker;
 exports.warmUpSession = warmUpSession;
 exports.withCometTokens = withCometTokens;