scripter-x 1.0.0

package/src/worker.js

@@ -0,0 +1,261 @@
+// Goal-driven extraction worker: keep going until N successful JSONs.
+// Async concurrency (no threads needed). Mirrors the server worker's semantics:
+//   goal = N JSONs, 4× attempt cap; refund rule (charge only if SMS arrived);
+//   OTP timing + wrong-OTP resend; every result pushed to the server (ingest).
+import { FlipkartLogin, WrongOTP, BlockedError, TransientError } from './flipkart.js';
+
+const OTP_RESEND_AFTER = 60_000;
+const OTPCART_DEADLINE = 120_000;
+const TEMPOTP_DEADLINE = 90_000;   // TempOTP: give up after 90s, cancel + buy a new number
+const WRONG_OTP_WAIT = 60_000;
+const NUMBER_CANCEL_LOCK = 120_000;
+const RENT_RETRY_DELAY = 3_000;
+const RENT_COOLDOWN_EVERY = 9;
+const RENT_COOLDOWN_SECS = 30;
+const ATTEMPT_CAP_MULT = 4;
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export class Worker {
+  constructor(api, provider, { campaignId, requested, concurrency, checkMinutes, onEvent, onFailure }) {
+    this.api = api;
+    this.provider = provider;
+    this.cid = campaignId;
+    this.requested = requested;
+    this.concurrency = Math.max(1, Math.min(concurrency, requested));
+    this.checkMinutes = checkMinutes;
+    this.onEvent = onEvent || (() => {});
+    // onFailure({mobile, reason}) → Promise<boolean>: true = keep going, false = stop campaign.
+    this.onFailure = onFailure || null;
+    this.stats = { total: requested, succeeded: 0, failed: 0, cancelled: 0, generated: 0, attempts: 0, charges: 0 };
+    this.slots = {};
+    this.seq = 0;
+    this.stopped = false;
+  }
+
+  stop() { this.stopped = true; }
+  _nextSeq() { return ++this.seq; }
+
+  _claim() {
+    if (this.stopped) return 0;
+    if (this.stats.succeeded >= this.requested) return 0;
+    if (this.stats.attempts >= this.requested * ATTEMPT_CAP_MULT) return 0;
+    return ++this.stats.attempts;
+  }
+
+  _emit(slot, kv) {
+    this.slots[slot] = { slot, ...(this.slots[slot] || {}), ...kv };
+    this.onEvent('slot', this.slots[slot]);
+  }
+
+  async _record(res) {
+    if (res.mobile) this.stats.generated++;
+    if (res.status === 'success') { this.stats.succeeded++; this.stats.charges += res.cost || 0; }
+    else if (res.status === 'cancelled') this.stats.cancelled++;
+    else { this.stats.failed++; this.stats.charges += res.cost || 0; } // failed w/ SMS = charged by provider
+    this.onEvent('progress', this.stats);
+    this.onEvent('row', res);
+    try {
+      await this.api.ingestAccount(this.cid, {
+        id_no: res.id_no, mobile: res.mobile || '', status: res.status, cost: res.cost || 0,
+        fail_reason: res.detail || '', session: res.session,
+        minutes_checked: !!res.minutes_checked, coupon_eligible: res.coupon_eligible ?? undefined,
+        has_minutes_order: res.has_minutes_order ?? undefined,
+      });
+    } catch (e) { this.onEvent('warn', `ingest failed: ${e.message}`); }
+  }
+
+  async run() {
+    await this.api.markRunning(this.cid);
+    const loops = Array.from({ length: this.concurrency }, (_, i) => this._loop(i + 1));
+    await Promise.all(loops);
+    const status = this.stopped ? 'cancelled' : 'completed';
+    const s = this.stats;
+    try {
+      await this.api.finishCampaign(this.cid, {
+        succeeded: s.succeeded, failed: s.failed, cancelled: s.cancelled,
+        numbers_generated: s.generated, attempts: s.attempts, charges: s.charges, status,
+      });
+    } catch (e) { this.onEvent('warn', `finish failed: ${e.message}`); }
+    this.onEvent('done', s);
+    return s;
+  }
+
+  async _loop(slot) {
+    for (;;) {
+      if (this._claim() === 0) return;
+      const res = await this._process(slot);
+      await this._record(res);
+    }
+  }
+
+  async _process(slot) {
+    const idNo = this._nextSeq();
+    const res = { id_no: idNo, status: 'failed', cost: 0, detail: '' };
+
+    this._emit(slot, { mobile: '', phase: 'renting', detail: 'requesting a number', wait: 0 });
+    const number = await this._rent(slot);
+    if (!number) { res.status = 'cancelled'; res.detail = 'stopped while renting'; return res; }
+    const rentedAt = Date.now();
+    res.mobile = number.mobile;
+    this._emit(slot, { mobile: number.mobile, phase: 'rented', detail: 'got a number' });
+
+    const smsArrived = { v: false };
+    const fk = new FlipkartLogin();
+    let stream = null;
+
+    const fail = (detail) => {
+      const charged = smsArrived.v;
+      res.status = charged ? 'failed' : 'cancelled';
+      res.cost = charged ? number.cost : 0;
+      res.detail = detail;
+      this._emit(slot, { phase: 'cancelling', detail: 'releasing number' });
+      this._release(number, rentedAt);
+      return res;
+    };
+
+    try {
+      this._emit(slot, { phase: 'ws', detail: 'opening OTP channel' });
+      stream = this.provider.startOtp(number);
+
+      this._emit(slot, { phase: 'send_otp', detail: 'sending OTP' });
+      try { await fk.sendOtp(number.mobile); }
+      catch (e) { return fail(`send: ${e.message}`); }
+
+      const deadline = this.provider.name === 'tempotp' ? TEMPOTP_DEADLINE : OTPCART_DEADLINE;
+      const doResend = this.provider.name === 'otpcart';
+      const otp = await this._awaitOtp(slot, stream, fk, number, deadline, doResend, smsArrived);
+      if (!otp) return fail(`no OTP within ${deadline / 1000}s — abandoned`);
+
+      this._emit(slot, { phase: 'verify', detail: 'verifying OTP' });
+      const { session, error: verifyErr } = await this._verify(slot, fk, stream, number, otp, smsArrived);
+      if (!session) {
+        // surface the REAL Flipkart reason, and (since the OTP SMS was delivered) charge it.
+        const failed = fail(verifyErr || 'verify failed');
+        // ask the user whether to keep going after a failure (one prompt at a time)
+        if (this.onFailure && !this.stopped && !this._asking) {
+          this._asking = true;
+          try {
+            const cont = await this.onFailure({ mobile: number.mobile, reason: verifyErr || 'verify failed' });
+            if (!cont) this.stopped = true; // stop the whole campaign
+          } finally { this._asking = false; }
+        }
+        return failed;
+      }
+
+      if (this.checkMinutes) {
+        this._emit(slot, { phase: 'minutes', detail: 'checking Minutes' });
+        try {
+          const avail = await fk.checkMinutes(session);
+          res.minutes_checked = true; res.coupon_eligible = avail; res.has_minutes_order = !avail;
+        } catch { /* non-fatal */ }
+      }
+
+      this._emit(slot, { phase: 'saving', detail: 'saving session' });
+      res.status = 'success'; res.cost = number.cost; res.session = session;
+      this._emit(slot, { phase: 'done', detail: 'extracted' });
+      this._release(number, rentedAt);
+      return res;
+    } finally {
+      if (stream) try { stream.close(); } catch { /* */ }
+    }
+  }
+
+  async _rent(slot) {
+    let attempt = 0;
+    while (!this.stopped) {
+      attempt++;
+      this._emit(slot, { phase: 'renting', detail: `requesting a number (try ${attempt})` });
+      const { number } = await this.provider.rentOnce();
+      if (number) return number;
+      if (attempt % RENT_COOLDOWN_EVERY === 0) {
+        for (let rem = RENT_COOLDOWN_SECS; rem > 0; rem--) {
+          if (this.stopped) return null;
+          this._emit(slot, { phase: 'rent_wait', detail: 'no numbers — waiting', wait: rem });
+          await sleep(1000);
+        }
+      } else {
+        await sleep(RENT_RETRY_DELAY);
+      }
+    }
+    return null;
+  }
+
+  async _awaitOtp(slot, stream, fk, number, deadline, doResend, smsArrived) {
+    const end = Date.now() + deadline;
+    const resendAt = Date.now() + OTP_RESEND_AFTER;
+    let resent = false;
+    while (Date.now() < end) {
+      if (this.stopped) return null;
+      const { otp, arrived } = await stream.poll();
+      if (arrived) smsArrived.v = true;
+      if (otp) return otp;
+      const rem = Math.floor((end - Date.now()) / 1000);
+      if (doResend && !resent && Date.now() >= resendAt) {
+        try { await fk.sendOtp(number.mobile); } catch { /* */ }
+        stream.resend(); resent = true;
+        this._emit(slot, { phase: 'otp_resend', detail: 'OTP resent', wait: rem });
+      } else {
+        this._emit(slot, { phase: 'await_otp', detail: 'waiting for OTP', wait: rem });
+      }
+      await sleep(1000);
+    }
+    return null;
+  }
+
+  // Verify the OTP. Returns { session, error } — error is a human reason on failure.
+  // Transient (529/5xx/IP) failures are RETRIED a few times before giving up, so they're
+  // not mislabeled as "OTP rejected".
+  async _verify(slot, fk, stream, number, otp, smsArrived) {
+    let lastErr = 'verify failed';
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        const session = await fk.verifyOtp(number.mobile, otp);
+        return { session, error: null };
+      } catch (e) {
+        if (e instanceof TransientError) {
+          lastErr = e.message;
+          this._emit(slot, { phase: 'verify', detail: `Flipkart busy — retry ${attempt}/3` });
+          await sleep(3000);
+          continue; // retry the SAME otp (it's still valid; the server just hiccupped)
+        }
+        if (e instanceof WrongOTP) {
+          // genuine wrong/expired code. OTPCart can ask for a fresh one; TempOTP can't (same txn).
+          if (this.provider.name === 'tempotp') return { session: null, error: e.message };
+          return this._resendAndVerify(slot, fk, stream, number, smsArrived, e.message);
+        }
+        return { session: null, error: e.message };
+      }
+    }
+    return { session: null, error: lastErr };
+  }
+
+  async _resendAndVerify(slot, fk, stream, number, smsArrived, why) {
+    this._emit(slot, { phase: 'otp_resend', detail: `${why} — resending`, wait: WRONG_OTP_WAIT / 1000 });
+    try { await fk.sendOtp(number.mobile); } catch (e) { return { session: null, error: `resend failed: ${e.message}` }; }
+    stream.resend();
+    const end = Date.now() + WRONG_OTP_WAIT;
+    let otp2 = null;
+    while (Date.now() < end && !this.stopped) {
+      const { otp: o, arrived } = await stream.poll();
+      if (arrived) smsArrived.v = true;
+      if (o) { otp2 = o; break; }
+      this._emit(slot, { phase: 'await_otp', detail: 'waiting for new OTP', wait: Math.floor((end - Date.now()) / 1000) });
+      await sleep(1000);
+    }
+    if (!otp2) return { session: null, error: 'no new OTP after resend' };
+    this._emit(slot, { phase: 'verify', detail: 'verifying OTP (retry)' });
+    try { return { session: await fk.verifyOtp(number.mobile, otp2), error: null }; }
+    catch (e) { return { session: null, error: e.message }; }
+  }
+
+  _release(number, rentedAt) {
+    (async () => {
+      if (this.provider.name === 'tempotp') {
+        const wait = NUMBER_CANCEL_LOCK - (Date.now() - rentedAt);
+        if (wait > 0) await sleep(wait);
+      }
+      try { await this.provider.cancel(number); } catch { /* */ }
+    })();
+  }
+}