zevairouter 1.0.152 → 1.0.154

package/src/lib/oauth/services/codebuddyCnPhoneAutomation.js

@@ -159,6 +159,59 @@ function shouldBlockCodeBuddyResource(url, resourceType) {
   return false;
 }
 
+async function clickSendSmsCodeButton(phoneFrame) {
+  const primary = phoneFrame.locator(iframeSelector(IFRAME_SEND_CODE_BTN)).first();
+  let selected = null;
+  try {
+    await primary.waitFor({ state: "visible", timeout: 5_000 });
+    selected = primary;
+  } catch {
+    const fallback = phoneFrame.locator(iframeSelector(IFRAME_SEND_CODE_BTN_ALT)).first();
+    try {
+      await fallback.waitFor({ state: "visible", timeout: 5_000 });
+      selected = fallback;
+    } catch {
+      selected = null;
+    }
+  }
+
+  if (!selected) return { ok: false, reason: "missing" };
+  const clicked = await selected.click().then(() => true).catch(() => false);
+  return { ok: clicked, reason: clicked ? null : "click_failed" };
+}
+
+async function waitForSmsCode(smsPromise, { timeoutMs, signal = null } = {}) {
+  let timer = null;
+  let onAbort = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error("Timed out waiting for SMS code")),
+      timeoutMs,
+    );
+    timer.unref?.();
+  });
+  const cancellation = signal
+    ? new Promise((_, reject) => {
+        onAbort = () => reject(signal.reason || Object.assign(new Error("Job cancelled"), {
+          code: "JOB_CANCELLED",
+        }));
+        if (signal.aborted) onAbort();
+        else signal.addEventListener("abort", onAbort, { once: true });
+      })
+    : null;
+
+  try {
+    return await Promise.race([
+      smsPromise,
+      timeout,
+      ...(cancellation ? [cancellation] : []),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (onAbort) signal?.removeEventListener("abort", onAbort);
+  }
+}
+
 /**
  * Run the phone-number registration automation.
  *
@@ -199,7 +252,13 @@ export async function runCodeBuddyCnPhoneRegistration({
 
   const reportStep = (step, message) => onStep?.(step, message);
   const throwIfCancelled = () => {
-    if (signal?.aborted || (typeof isCancelled === "function" && isCancelled())) {
+    if (signal?.aborted) {
+      if (signal.reason?.code === "CN_ACCOUNT_HARD_TIMEOUT") throw signal.reason;
+      const err = new Error("Job cancelled");
+      err.code = "JOB_CANCELLED";
+      throw err;
+    }
+    if (typeof isCancelled === "function" && isCancelled()) {
       const err = new Error("Job cancelled");
       err.code = "JOB_CANCELLED";
       throw err;
@@ -406,28 +465,19 @@ export async function runCodeBuddyCnPhoneRegistration({
 
     // Step 6: Click "获取验证码" (send SMS code)
     reportStep("cn_clicking_send_code", "Clicking send SMS code button");
-    const sendBtn = phoneFrame.locator(iframeSelector(IFRAME_SEND_CODE_BTN)).first();
-    let sendBtnVisible = false;
-    try {
-      await sendBtn.waitFor({ state: "visible", timeout: 5_000 });
-      sendBtnVisible = true;
-    } catch {
-      // Try alternate selector
-      const sendBtnAlt = phoneFrame.locator(iframeSelector(IFRAME_SEND_CODE_BTN_ALT)).first();
-      try {
-        await sendBtnAlt.waitFor({ state: "visible", timeout: 5_000 });
-        sendBtnVisible = true;
-      } catch {
-        sendBtnVisible = false;
-      }
-    }
-    if (!sendBtnVisible) {
+    const sendResult = await clickSendSmsCodeButton(phoneFrame);
+    if (sendResult.reason === "missing") {
       return {
         status: "failed",
         error: "Could not find the send-SMS-code button (.code-btn) inside the iframe",
       };
     }
-    await sendBtn.click().catch(() => {});
+    if (!sendResult.ok) {
+      return {
+        status: "failed",
+        error: "Could not click the send-SMS-code button (.code-btn) inside the iframe",
+      };
+    }
     reportStep("cn_send_code_clicked", "Send code button clicked");
 
     // Check for immediate error (e.g. invalid phone, rate limit) — wait for error or code input to be ready
@@ -454,13 +504,11 @@ export async function runCodeBuddyCnPhoneRegistration({
       } else {
         throw new Error("No waitForSms/pollSmsPromise provided");
       }
-      const codeTimeoutPromise = new Promise((_, reject) =>
-        setTimeout(() => reject(new Error("Timed out waiting for SMS code")), codeWait),
-      );
-      smsCode = await Promise.race([smsPromise, codeTimeoutPromise]);
+      smsCode = await waitForSmsCode(smsPromise, { timeoutMs: codeWait, signal });
     } catch (err) {
       // Re-throw FiveSimTimeoutError so processAccount can BAN the number
       if (err && err.name === "FiveSimTimeoutError") throw err;
+      if (signal?.aborted || err?.code === "JOB_CANCELLED") throwIfCancelled();
       return {
         status: "failed",
         error: `Failed to receive SMS code: ${err.message}`,
@@ -676,8 +724,12 @@ export async function runCodeBuddyCnPhoneRegistration({
       error: `Login submit finished but no Keycloak session yet (${diag.summary}). Complete login in the headed browser or retry with a fresh China proxy.`,
     };
   } catch (err) {
+    if (signal?.aborted || (typeof isCancelled === "function" && isCancelled())) {
+      throwIfCancelled();
+    }
     // Re-throw FiveSimTimeoutError so processAccount can BAN the number
     if (err && err.name === "FiveSimTimeoutError") throw err;
+    if (err?.code === "JOB_CANCELLED" || err?.code === "CN_ACCOUNT_HARD_TIMEOUT") throw err;
     reportStep("cn_automation_error", `Phone registration automation error: ${err.message}`);
     return {
       status: "failed",
@@ -864,17 +916,23 @@ async function selectCountry(frame, targetCountryCode, actionTimeout, reportStep
     await frame.locator("body").click({ timeout: 1_000 }).catch(() => {});
   };
 
+  let timeoutHandle = null;
   try {
     await Promise.race([
       run(),
       new Promise((_, reject) => {
-        const t = setTimeout(() => reject(new Error(`selectCountry timed out after ${budgetMs}ms`)), budgetMs);
-        if (typeof t.unref === "function") t.unref();
+        timeoutHandle = setTimeout(
+          () => reject(new Error(`selectCountry timed out after ${budgetMs}ms`)),
+          budgetMs,
+        );
+        timeoutHandle.unref?.();
       }),
     ]);
   } catch (err) {
     reportStep?.("cn_country_select_error", `Country selection error: ${err.message}`);
     // Non-fatal — continue with default country
+  } finally {
+    if (timeoutHandle) clearTimeout(timeoutHandle);
   }
 }
 
@@ -1231,4 +1289,6 @@ export const __test__ = {
   hasRestrictionCookie,
   restrictedRegistrationResult,
   shouldBlockCodeBuddyResource,
+  clickSendSmsCodeButton,
+  waitForSmsCode,
 };

package/src/lib/oauth/services/fiveSimClient.js

@@ -22,7 +22,21 @@ const FIVESIM_BASE_URL = "https://5sim.net/v1";
 const nativeFetch = globalThis.fetch;
 const DEFAULT_POLL_INTERVAL_MS = 6000; // >5s safe floor per 5sim guidance
 const DEFAULT_POLL_TIMEOUT_MS = 15 * 60_000; // 15 min (5sim number expiry is ~20 min)
+const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
+const DEFAULT_BUY_RESPONSE_TIMEOUT_MS = 20_000;
+const DEFAULT_BUY_LATE_ABORT_TIMEOUT_MS = 45_000;
 const MAX_TRANSIENT_ERRORS = 5;
+const TRANSIENT_NETWORK_CODES = new Set([
+  "ECONNABORTED",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETDOWN",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "EPIPE",
+  "ETIMEDOUT",
+]);
 
 // Terminal 5sim order statuses that mean "no more SMS will arrive"
 const TERMINAL_STATUSES = new Set([
@@ -52,6 +66,25 @@ export class FiveSimTimeoutError extends FiveSimError {
   }
 }
 
+export class FiveSimRequestTimeoutError extends FiveSimError {
+  constructor(path, timeoutMs) {
+    super(`5sim request to ${path} timed out after ${timeoutMs}ms`);
+    this.name = "FiveSimRequestTimeoutError";
+    this.code = "FIVESIM_REQUEST_TIMEOUT";
+    this.path = path;
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+export class FiveSimUnknownOutcomeError extends FiveSimError {
+  constructor(message) {
+    super(message);
+    this.name = "FiveSimUnknownOutcomeError";
+    this.code = "FIVESIM_BUY_OUTCOME_UNKNOWN";
+    this.outcomeUnknown = true;
+  }
+}
+
 export class FiveSimCancelledError extends FiveSimError {
   constructor(orderId, reason) {
     super(`5sim order ${orderId} cancelled: ${reason}`);
@@ -76,12 +109,13 @@ export class FiveSimBannedError extends FiveSimError {
  * @param {object} [opts.proxyOptions] Passed to proxyAwareFetch (respect outbound proxy / per-connection proxy)
  */
 export class FiveSimClient {
-  constructor({ apiKey, proxyOptions = null } = {}) {
+  constructor({ apiKey, proxyOptions = null, fetchImpl = null } = {}) {
     if (!apiKey || typeof apiKey !== "string" || !apiKey.trim()) {
       throw new FiveSimError("5sim API key is required");
     }
     this.apiKey = apiKey.trim();
     this.proxyOptions = proxyOptions;
+    this.fetchImpl = typeof fetchImpl === "function" ? fetchImpl : null;
   }
 
   _headers(extra = {}) {
@@ -92,40 +126,84 @@ export class FiveSimClient {
     };
   }
 
-  async _get(path, { headers, ...fetchOpts } = {}) {
+  async _get(path, {
+    headers,
+    timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+    signal: callerSignal,
+    ...fetchOpts
+  } = {}) {
     const url = `${FIVESIM_BASE_URL}${path}`;
     // Use native fetch for 5sim API — proxyAwareFetch's MITM DNS bypass logic
     // can interfere with 5sim.net resolution and cause silent poll failures.
     // Proxy support is still available via proxyOptions if explicitly configured.
-    const fetchFn = this.proxyOptions?.enabled ? proxyAwareFetch : nativeFetch;
-    const res = await fetchFn(url, {
-      method: "GET",
-      headers: this._headers(headers),
-      ...fetchOpts,
-    }, this.proxyOptions);
-
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      // 404 "no free phones" is a common, recoverable condition — surface it
-      throw new FiveSimError(
-        `5sim request to ${path} failed (HTTP ${res.status}): ${text.slice(0, 200)}`,
-        { status: res.status, body: text },
-      );
-    }
-
-    // Some 5sim endpoints return plain text errors with 200 (e.g. "no free phones")
-    const text = await res.text();
+    const fetchFn = this.fetchImpl
+      || (this.proxyOptions?.enabled ? proxyAwareFetch : nativeFetch);
+    const timeoutController = Number.isFinite(timeoutMs) && timeoutMs > 0
+      ? new AbortController()
+      : null;
+    const timeoutSignal = timeoutController?.signal || null;
+    const timeoutTimer = timeoutController
+      ? setTimeout(() => timeoutController.abort(), timeoutMs)
+      : null;
+    timeoutTimer?.unref?.();
+    const requestSignal = combineAbortSignals([callerSignal, timeoutSignal]);
+    const normalizeRequestFailure = (error) => {
+      if (callerSignal?.aborted) {
+        const aborted = new FiveSimError(`5sim request to ${path} was aborted`);
+        aborted.code = "FIVESIM_REQUEST_ABORTED";
+        aborted.cause = error;
+        return aborted;
+      }
+      if (timeoutSignal?.aborted) {
+        const timedOut = new FiveSimRequestTimeoutError(path, timeoutMs);
+        timedOut.cause = error;
+        return timedOut;
+      }
+      return error;
+    };
+    let res;
     try {
-      return JSON.parse(text);
-    } catch {
-      // Non-JSON 200 response — treat as an error message
-      if (text && !text.startsWith("{")) {
-        throw new FiveSimError(`5sim ${path} returned non-JSON: ${text.slice(0, 200)}`, {
-          status: res.status,
-          body: text,
-        });
+      try {
+        res = await fetchFn(url, {
+          method: "GET",
+          headers: this._headers(headers),
+          ...fetchOpts,
+          ...(requestSignal ? { signal: requestSignal } : {}),
+        }, this.proxyOptions);
+      } catch (error) {
+        throw normalizeRequestFailure(error);
+      }
+
+      let text;
+      try {
+        text = await res.text();
+      } catch (error) {
+        throw normalizeRequestFailure(error);
+      }
+
+      if (!res.ok) {
+        // 404 "no free phones" is a common, recoverable condition — surface it
+        throw new FiveSimError(
+          `5sim request to ${path} failed (HTTP ${res.status}): ${text.slice(0, 200)}`,
+          { status: res.status, body: text },
+        );
+      }
+
+      // Some 5sim endpoints return plain text errors with 200 (e.g. "no free phones")
+      try {
+        return JSON.parse(text);
+      } catch {
+        // Non-JSON 200 response — treat as an error message
+        if (text && !text.startsWith("{")) {
+          throw new FiveSimError(`5sim ${path} returned non-JSON: ${text.slice(0, 200)}`, {
+            status: res.status,
+            body: text,
+          });
+        }
+        return null;
       }
-      return null;
+    } finally {
+      if (timeoutTimer) clearTimeout(timeoutTimer);
     }
   }
 
@@ -149,7 +227,15 @@ export class FiveSimClient {
     operator = "any",
     product = "codebuddy",
     allowProductFallback = false,
+    responseTimeoutMs = DEFAULT_BUY_RESPONSE_TIMEOUT_MS,
+    lateAbortTimeoutMs = DEFAULT_BUY_LATE_ABORT_TIMEOUT_MS,
+    signal = null,
   } = {}) {
+    if (signal?.aborted) {
+      const error = new FiveSimError("5sim purchase cancelled before the request started");
+      error.code = "FIVESIM_REQUEST_ABORTED";
+      throw error;
+    }
     const products =
       product === "codebuddy" && allowProductFallback
         ? ["codebuddy", "other"]
@@ -159,7 +245,26 @@ export class FiveSimClient {
     for (const candidate of products) {
       const path = `/user/buy/activation/${encodeURIComponent(country)}/${encodeURIComponent(operator)}/${encodeURIComponent(candidate)}`;
       try {
-        const data = await this._get(path);
+        // 5sim uses a GET for this state-changing purchase. Return control on a
+        // short response deadline, but keep the bounded request alive briefly so
+        // a late successful order can be cancelled instead of leaking balance.
+        const hardRequestTimeoutMs = Math.max(
+          Number(lateAbortTimeoutMs) || DEFAULT_BUY_LATE_ABORT_TIMEOUT_MS,
+          (Number(responseTimeoutMs) || DEFAULT_BUY_RESPONSE_TIMEOUT_MS) + 1_000,
+        );
+        const request = this._get(path, { timeoutMs: hardRequestTimeoutMs });
+        let data;
+        try {
+          data = await raceBuyResponse(request, responseTimeoutMs, signal);
+        } catch (error) {
+          if (error?.code === "FIVESIM_BUY_OUTCOME_UNKNOWN") {
+            void request.then((lateOrder) => {
+              if (lateOrder?.id) return this.cancelOrder(lateOrder.id);
+              return null;
+            }).catch(() => null);
+          }
+          throw error;
+        }
         if (!data || !data.id || !data.phone) {
           throw new FiveSimError(`5sim buyNumber returned unexpected shape: ${JSON.stringify(data).slice(0, 200)}`, {
             body: data,
@@ -195,8 +300,8 @@ export class FiveSimClient {
    * @param {number} id  Order ID from buyNumber
    * @returns {Promise<object>}  Order shape: { id, phone, sms:[{code,text,sender,...}], status }
    */
-  async checkOrder(id) {
-    return this._get(`/user/check/${id}`);
+  async checkOrder(id, options = {}) {
+    return this._get(`/user/check/${id}`, options);
   }
 
   /**
@@ -211,9 +316,26 @@ export class FiveSimClient {
    * @throws {FiveSimTimeoutError|FiveSimCancelledError|FiveSimBannedError|FiveSimError}
    */
   async pollCode(id, { timeoutMs = DEFAULT_POLL_TIMEOUT_MS, intervalMs = DEFAULT_POLL_INTERVAL_MS, signal } = {}) {
-    const interval = Math.max(5000, intervalMs); // enforce 5sim's 5s floor
-    const deadline = Date.now() + timeoutMs;
+    const requestedInterval = Number(intervalMs);
+    const interval = Number.isFinite(requestedInterval)
+      ? Math.max(5000, requestedInterval)
+      : DEFAULT_POLL_INTERVAL_MS;
+    const requestedTimeout = Number(timeoutMs);
+    const pollTimeout = Number.isFinite(requestedTimeout) && requestedTimeout > 0
+      ? requestedTimeout
+      : DEFAULT_POLL_TIMEOUT_MS;
+    const deadline = Date.now() + pollTimeout;
     let transientErrors = 0;
+    const waitForNextPoll = async () => {
+      try {
+        await sleep(interval, signal);
+      } catch (error) {
+        if (signal?.aborted) {
+          throw new FiveSimCancelledError(id, "aborted by caller");
+        }
+        throw error;
+      }
+    };
 
     while (Date.now() < deadline) {
       if (signal?.aborted) {
@@ -222,13 +344,19 @@ export class FiveSimClient {
 
       let order;
       try {
-        order = await this.checkOrder(id);
+        order = await this.checkOrder(id, { signal });
       } catch (err) {
+        if (signal?.aborted || err?.code === "FIVESIM_REQUEST_ABORTED") {
+          throw new FiveSimCancelledError(id, "aborted by caller");
+        }
         // Transient network/server errors — retry up to a limit
-        if (err instanceof FiveSimError && err.status >= 500) {
+        if (
+          err instanceof FiveSimRequestTimeoutError
+          || isTransientRequestError(err)
+        ) {
           transientErrors++;
           if (transientErrors > MAX_TRANSIENT_ERRORS) throw err;
-          await sleep(interval);
+          await waitForNextPoll();
           continue;
         }
         throw err;
@@ -256,7 +384,7 @@ export class FiveSimClient {
         }
       }
 
-      await sleep(interval);
+      await waitForNextPoll();
     }
 
     throw new FiveSimTimeoutError(id);
@@ -322,6 +450,15 @@ export class FiveSimClient {
   }
 }
 
+function isTransientRequestError(error) {
+  if (error instanceof FiveSimError) {
+    return error.status === 408 || error.status === 429 || error.status >= 500;
+  }
+  if (error instanceof TypeError) return true;
+  const code = error?.code || error?.cause?.code;
+  return TRANSIENT_NETWORK_CODES.has(code);
+}
+
 /**
  * Extract a numeric verification code from an 5sim SMS object.
  * 5sim sometimes provides a pre-parsed `code` field; otherwise extract digits from `text`.
@@ -358,8 +495,62 @@ function findCodeInText(text) {
   return match ? match[1] : null;
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function combineAbortSignals(signals) {
+  const active = signals.filter(Boolean);
+  if (active.length === 0) return null;
+  if (active.length === 1) return active[0];
+  if (typeof AbortSignal.any === "function") return AbortSignal.any(active);
+
+  const controller = new AbortController();
+  for (const signal of active) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+
+async function raceBuyResponse(request, timeoutMs, signal = null) {
+  const budget = Number(timeoutMs) || DEFAULT_BUY_RESPONSE_TIMEOUT_MS;
+  let timer = null;
+  let onAbort = null;
+  const interrupted = new Promise((_, reject) => {
+    const rejectUnknown = (reason) => reject(new FiveSimUnknownOutcomeError(
+      `5sim buy request ${reason}; purchase outcome is unknown and any late successful order will be cancelled automatically`,
+    ));
+    timer = setTimeout(() => {
+      rejectUnknown(`did not answer within ${budget}ms`);
+    }, budget);
+    timer.unref?.();
+    onAbort = () => rejectUnknown("was interrupted by the caller");
+    if (signal?.aborted) onAbort();
+    else signal?.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([request, interrupted]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (onAbort) signal?.removeEventListener("abort", onAbort);
+  }
+}
+
+function sleep(ms, signal = null) {
+  if (signal?.aborted) return Promise.reject(signal.reason || new Error("Aborted"));
+  return new Promise((resolve, reject) => {
+    const cleanup = () => signal?.removeEventListener("abort", onAbort);
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      cleanup();
+      reject(signal.reason || new Error("Aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
 }
 
 export const __test__ = {
@@ -367,4 +558,10 @@ export const __test__ = {
   findCodeInText,
   TERMINAL_STATUSES,
   FIVESIM_BASE_URL,
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  DEFAULT_BUY_RESPONSE_TIMEOUT_MS,
+  DEFAULT_BUY_LATE_ABORT_TIMEOUT_MS,
+  combineAbortSignals,
+  raceBuyResponse,
+  isTransientRequestError,
 };