scripter-x 1.0.25 → 1.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scripter-x",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "ScripterX — local Flipkart session extractor (runs on your residential IP, syncs to marthunt)",
   "type": "module",
   "bin": {

package/src/flipkart.js

@@ -88,34 +88,68 @@ export class FlipkartLogin {
     this.isNewUser = false; // set by sendOtp: new number → verify as SIGNUP, not LOGIN
   }
 
-  async sendOtp(mobile) {
-    await throttle.wait();
+  // Send-OTP variants. The NATIVE app flow (okhttp UA, .net host, app body with
+  // addAppHash/phoneNumberFormat) is far less throttled than the browser/web flow —
+  // it mirrors exactly what the Flipkart app sends (captured). We try native first,
+  // and fall back to the web flow only if native yields no requestId.
+  async _sendNative(mobile) {
+    const body = { actionRequestContext: {
+      type: 'LOGIN_IDENTITY_VERIFY', loginId: mobile.slice(-10), loginIdPrefix: '+91',
+      phoneNumberFormat: 'E164', addAppHash: true, loginType: 'MOBILE',
+      verificationType: 'OTP', sourceContext: 'DEFAULT',
+      correlationId: null, snaFlowId: null, clientQueryParamMap: null } };
+    const res = await fetch(`${NATIVE_HOST}/1/action/view`, {
+      method: 'POST', body: JSON.stringify(body),
+      headers: {
+        'User-Agent': 'okhttp/4.9.2', 'X-User-Agent': nativeUa(this.vid),
+        'Content-Type': 'application/json; charset=UTF-8',
+        'x-request-metaInfo': '{"actionType":"LOGIN_IDENTITY_VERIFY","pageUri":"questContext"}',
+      },
+    });
+    return res;
+  }
+
+  async _sendWeb(mobile) {
     const body = { actionRequestContext: {
       type: 'LOGIN_IDENTITY_VERIFY', loginIdPrefix: '+91', loginId: mobile.slice(-10),
       clientQueryParamMap: { ret: '/my-account', entryPage: 'DEFAULT' },
       loginType: 'MOBILE', verificationType: 'OTP', screenName: 'LOGIN_V4_MOBILE',
       triggerSna: false, sourceContext: 'DEFAULT' } };
-    let res;
-    try {
-      res = await fetch(`${WEB_HOST}/1/action/view`, {
-        method: 'POST', body: JSON.stringify(body),
-        headers: {
-          Accept: '*/*', 'Content-Type': 'application/json',
-          'X-User-Agent': FKUA, 'User-Agent': FKUA,
-          Origin: 'https://www.flipkart.com', Referer: 'https://www.flipkart.com/',
-          'sec-ch-ua-mobile': '?1', 'sec-ch-ua-platform': '"iOS"', 'sec-fetch-site': 'same-site',
-          'x-request-metaInfo': '{"actionType":"LOGIN_IDENTITY_VERIFY","pageUri":"questContext"}',
-        },
-      });
-    } catch (e) { throw new TransientError(`send network error: ${e.message}`); }
-    // 529/5xx = Flipkart overloaded / blocking this IP — retryable.
-    if (res.status === 429 || res.status === 529 || res.status >= 500) {
-      throw new TransientError(`Flipkart busy on send (HTTP ${res.status})`);
+    return fetch(`${WEB_HOST}/1/action/view`, {
+      method: 'POST', body: JSON.stringify(body),
+      headers: {
+        Accept: '*/*', 'Content-Type': 'application/json',
+        'X-User-Agent': FKUA, 'User-Agent': FKUA,
+        Origin: 'https://www.flipkart.com', Referer: 'https://www.flipkart.com/',
+        'sec-ch-ua-mobile': '?1', 'sec-ch-ua-platform': '"iOS"', 'sec-fetch-site': 'same-site',
+        'x-request-metaInfo': '{"actionType":"LOGIN_IDENTITY_VERIFY","pageUri":"questContext"}',
+      },
+    });
+  }
+
+  async sendOtp(mobile) {
+    await throttle.wait();
+    // The WEB flow establishes the SN session cookie that VERIFY needs, so it runs
+    // FIRST. If it throttles (200 but no requestId), retry on the NATIVE app flow —
+    // which is much less throttled and now reuses the SN web just set. Either flow
+    // that yields a requestId wins.
+    let res, data, rid;
+    for (const send of [this._sendWeb.bind(this), this._sendNative.bind(this)]) {
+      try {
+        res = await send(mobile);
+      } catch (e) { throw new TransientError(`send network error: ${e.message}`); }
+      // 529/5xx = Flipkart overloaded / blocking this IP — retryable.
+      if (res.status === 429 || res.status === 529 || res.status >= 500) {
+        throw new TransientError(`Flipkart busy on send (HTTP ${res.status})`);
+      }
+      parseCookies(res, this.jar);
+      // capture SN as soon as any flow provides it (web normally does)
+      if (this.jar.SN) { this.sn = this.jar.SN; this.vid = this.sn.split('.')[0]; }
+      data = await res.json().catch(() => ({}));
+      rid = data?.RESPONSE?.actionResponseContext?.requestId;
+      if (rid) break; // got it — done
     }
-    parseCookies(res, this.jar);
-    const data = await res.json().catch(() => ({}));
-    const rid = data?.RESPONSE?.actionResponseContext?.requestId;
-    // no requestId on a 200 = soft anti-bot throttle — also retryable (often clears on retry).
+    // no requestId after both flows = soft anti-bot throttle — retryable (often clears on retry).
     if (!rid) throw new TransientError('blocked while sending OTP (no requestId — throttled)');
     this.reqId = rid;
     // NEW vs EXISTING account: for an UNREGISTERED number FK still sends the OTP but
@@ -205,11 +239,15 @@ export class FlipkartLogin {
     parseCookies(res, fresh);
     const ud = fresh.ud || this.jar.ud || '';
     const vd = fresh.vd || '';
+    // secureToken: prefer the value FK returns in the SESSION (vid:vid); fall back to
+    // computing it from vid. (Was a free var in the old single-method verify — the
+    // SIGNUP/LOGIN split moved its definition into _verifyWith, hence recompute here.)
+    const secureToken = env.secureToken || (this.vid ? `${this.vid}:${this.vid}` : '');
     return {
       accountId: env.accountId || '', at: env.at || '', rt: env.rt || '', sn: env.sn || '',
       secureToken, secureCookie: this.jar.S || '', ud, vd,
       cookie_T: fresh.T || this.jar.T || '', // T cookie — needed for the email-attach calls
-      visitId: (env.sn || '').split('.')[0], nsid: env.nsid || '',
+      visitId: env.vid || (env.sn || '').split('.')[0], nsid: env.nsid || '',
       mobileNo: mobile.slice(-10), isLoggedIn: true, rt_expires_at: rtExpiry(env.rt || ''),
     };
   }

package/src/ui/RunView.js

@@ -30,14 +30,35 @@ function SlotRow({ slot, mobile, phase, detail, wait }) {
   );
 }
 
-function ResultRow({ status, mobile, detail, coupon, cost }) {
-  const st = STATUS[status] || STATUS.pending;
+// Map a result to a clean { glyph, label, color, note } for display. Driven by the
+// worker's `category` so every outcome reads consistently (no "successed"/"success" mix).
+function resultDisplay({ status, category, detail }) {
+  const C = COLORS;
+  switch (category) {
+    case 'fresh':            return { glyph: '🆕', label: 'fresh account',  color: C.accent,  note: 'new account created' };
+    case 'coupon':           return { glyph: '✓',  label: 'success',        color: C.success, note: '₹100 coupon available' };
+    case 'no_coupon':        return { glyph: '✓',  label: 'success',        color: C.success, note: 'no ₹100 coupon' };
+    case 'extracted':        return { glyph: '✓',  label: 'success',        color: C.success, note: 'extracted' };
+    case 'timeout':          return { glyph: '⏱',  label: 'timeout',        color: C.warn,    note: 'no OTP in 90s' };
+    case 'cancelled_user':   return { glyph: '⊘',  label: 'cancelled',      color: C.warn,    note: 'cancelled by user' };
+    case 'wrong_otp':        return { glyph: '✗',  label: 'failed',         color: C.danger,  note: 'wrong OTP code' };
+    case 'goal_reached':     return { glyph: '•',  label: 'skipped',        color: C.muted,   note: 'goal reached' };
+    case 'failed':           return { glyph: '✗',  label: 'failed',         color: C.danger,  note: detail || 'failed' };
+    default: {
+      const st = STATUS[status] || STATUS.pending;
+      const note = status === 'success' ? 'extracted' : (detail || '');
+      return { glyph: st.glyph, label: status, color: st.color, note };
+    }
+  }
+}
+
+function ResultRow({ status, category, mobile, detail, cost }) {
+  const d = resultDisplay({ status, category, detail });
   const mob = (mobile || '—').slice(-10) || '—';
-  const text = status === 'success' ? (coupon ? '₹100 coupon' : 'extracted') : (detail || '');
   return h(Box, null,
     h(Box, { width: 13 }, h(Text, null, mob)),
-    h(Box, { width: 13 }, h(Text, { color: st.color }, `${st.glyph} ${status}`)),
-    h(Box, { flexGrow: 1 }, h(Text, { color: 'gray' }, text)),
+    h(Box, { width: 14 }, h(Text, { color: d.color }, `${d.glyph} ${d.label}`)),
+    h(Box, { flexGrow: 1 }, h(Text, { color: 'gray' }, d.note)),
     h(Box, { width: 7, justifyContent: 'flex-end' }, h(Text, { color: 'gray' }, cost ? `₹${cost}` : '')),
   );
 }
@@ -76,7 +97,7 @@ export function RunView({ controller }) {
       slotList.length ? slotList.map((sl) => h(SlotRow, { key: sl.slot, ...sl }))
         : h(Text, { color: 'gray' }, 'starting…')),
     h(Panel, { title: 'results' },
-      lastRows.length ? lastRows.map((r, i) => h(ResultRow, { key: i, status: r.status, mobile: r.mobile, detail: r.detail, coupon: r.coupon_eligible, cost: r.cost }))
+      lastRows.length ? lastRows.map((r, i) => h(ResultRow, { key: i, status: r.status, category: r.category, mobile: r.mobile, detail: r.detail, cost: r.cost }))
         : h(Text, { color: 'gray' }, 'waiting for first result…')),
     h(Box, { borderStyle: 'round', borderColor: COLORS.accent, paddingX: 1 },
       h(Text, { color: COLORS.success }, `✓ ${stats.succeeded}`),

package/src/util.js

@@ -61,36 +61,51 @@ function writeAccounts(accounts, { name, out, checkMinutes } = {}) {
     return dest;
   }
 
-  // Partition by coupon_eligible when the Minutes check was requested.
-  const minutesFree = [];   // coupon_eligible=true  → no Minutes order, ₹100 coupon available
-  const minutesUsed = [];   // coupon_eligible=false → already placed a Minutes order
-  const unchecked = [];      // coupon_eligible absent → check wasn't done
+  // Partition into the THREE buckets the user wants:
+  //   fresh    → brand-new account just created (signup)
+  //   coupon   → existing account with the ₹100 Minutes coupon available
+  //   noCoupon → existing account, coupon already used
+  // plus `unchecked` (Minutes wasn't checked). Categorisation prefers the explicit
+  // `category` set by the worker; falls back to is_new_account / coupon_eligible.
+  const fresh = [];
+  const coupon = [];
+  const noCoupon = [];
+  const unchecked = [];
 
   let hasChecked = false;
   for (const a of accounts) {
     const sess = a.session;
     if (!sess) continue;
+    const cat = a.category;
     const eligible = a.coupon_eligible;
-    if (eligible !== undefined && eligible !== null) {
+    if (cat === 'fresh' || a.is_new_account) {
+      fresh.push(sess);
+      hasChecked = true;
+    } else if (cat === 'coupon' || eligible === true) {
+      coupon.push(sess);
+      hasChecked = true;
+    } else if (cat === 'no_coupon' || eligible === false) {
+      noCoupon.push(sess);
       hasChecked = true;
-      (eligible ? minutesFree : minutesUsed).push(sess);
     } else {
       unchecked.push(sess);
     }
   }
 
   const results = [];
-  if (hasChecked || (checkMinutes && (minutesFree.length || minutesUsed.length))) {
-    const destFree = write('-minutes-free', minutesFree);
-    if (destFree) results.push({ label: '🟢 minutes-free (₹100 coupon)', path: destFree, count: minutesFree.length });
-    const destUsed = write('-minutes-used', minutesUsed);
-    if (destUsed) results.push({ label: '🔴 minutes-used (coupon gone)', path: destUsed, count: minutesUsed.length });
+  if (hasChecked || (checkMinutes && (fresh.length || coupon.length || noCoupon.length))) {
+    const dFresh = write('-fresh-new-account', fresh);
+    if (dFresh) results.push({ label: '🆕 fresh new account', path: dFresh, count: fresh.length });
+    const dCoupon = write('-with-100-coupon', coupon);
+    if (dCoupon) results.push({ label: '🟢 ₹100 coupon available', path: dCoupon, count: coupon.length });
+    const dNo = write('-no-100-coupon', noCoupon);
+    if (dNo) results.push({ label: '🔴 no ₹100 coupon', path: dNo, count: noCoupon.length });
     if (unchecked.length) {
-      const destUnk = write('-unchecked', unchecked);
-      if (destUnk) results.push({ label: '⚪ unchecked', path: destUnk, count: unchecked.length });
+      const dUnk = write('-unchecked', unchecked);
+      if (dUnk) results.push({ label: '⚪ unchecked', path: dUnk, count: unchecked.length });
     }
   } else {
-    const allSessions = [...minutesFree, ...minutesUsed, ...unchecked];
+    const allSessions = [...fresh, ...coupon, ...noCoupon, ...unchecked];
     const dest = write('', allSessions);
     if (dest) results.push({ label: 'combined', path: dest, count: allSessions.length });
   }

package/src/worker.js

@@ -78,6 +78,8 @@ export class Worker {
     if (res.status === 'success' && res.session) {
       this.results.push({
         id_no: res.id_no, mobile: res.mobile || '', session: res.session,
+        category: res.category,                 // 'fresh' | 'coupon' | 'no_coupon' | 'extracted'
+        is_new_account: !!res.is_new_account,
         minutes_checked: !!res.minutes_checked,
         coupon_eligible: res.coupon_eligible ?? undefined,
         has_minutes_order: res.has_minutes_order ?? undefined,
@@ -152,18 +154,25 @@ export class Worker {
       this._emit(slot, { phase: 'done', detail: 'goal reached' });
       res.status = 'cancelled';
       res.detail = 'goal reached';
+      res.category = 'goal_reached';
       return res;
     }
 
     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; }
+    if (!number) {
+      res.status = 'cancelled';
+      res.detail = this.stopped ? 'cancelled by user' : 'stopped while renting';
+      res.category = this.stopped ? 'cancelled_user' : 'goal_reached';
+      return res;
+    }
     if (this.stats.succeeded >= this.requested) {
       this.log(`goal reached by another slot; releasing ${number.mobile} immediately`);
       this._release(number, Date.now(), slot);
       this._emit(slot, { phase: 'done', detail: 'goal reached' });
       res.status = 'cancelled';
       res.detail = 'goal reached';
+      res.category = 'goal_reached';
       return res;
     }
     const rentedAt = Date.now();
@@ -194,11 +203,13 @@ export class Worker {
       this._release(number, rentedAt, slot);
     };
 
-    const fail = (detail) => {
+    const fail = (detail, category) => {
       const charged = smsArrived.v;
       res.status = charged ? 'failed' : 'cancelled';
       res.cost = charged ? number.cost : 0;
       res.detail = detail;
+      // category: timeout (90s, no OTP), wrong_otp, send_blocked, or generic failed/cancelled
+      res.category = category || (res.status === 'failed' ? 'failed' : 'cancelled');
       this.log(`FAILED ${number.mobile}: ${detail} (charged: ${charged})`);
       releaseOnce(charged, 'failed');
       return res;
@@ -224,13 +235,14 @@ export class Worker {
       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`);
+      if (!otp) return fail(`no OTP in ${deadline / 1000}s (timeout)`, 'timeout');
 
       // 3. VERIFY (already retries transients internally via _verify; re-verify on blockage)
       this._emit(slot, { phase: 'verify', detail: 'verifying OTP' });
       const { session, error: verifyErr } = await this._verify(slot, fk, stream, number, otp, smsArrived);
       if (!session) {
-        const failed = fail(verifyErr || 'verify failed');
+        const isWrongOtp = /incorrect|wrong|invalid|expired|code/i.test(verifyErr || '');
+        const failed = fail(verifyErr || 'verify failed', isWrongOtp ? 'wrong_otp' : 'failed');
         if (this.onFailure && !this.stopped && !this._asking) {
           this._asking = true;
           try {
@@ -282,7 +294,17 @@ export class Worker {
       res.status = 'success';
       res.cost = number.cost;
       res.session = session;
-      const doneDetail = res.email_linked ? `extracted + ${res.linked_email}` : 'extracted';
+      res.is_new_account = !!fk.isNewUser; // a freshly-created (signup) account
+      // Derive the result CATEGORY for display + file routing:
+      //   fresh     → brand-new account just created
+      //   coupon    → existing account, ₹100 Minutes coupon available
+      //   no_coupon → existing account, coupon already used
+      //   extracted → success but Minutes wasn't checked
+      res.category = res.is_new_account ? 'fresh'
+        : (res.minutes_checked ? (res.coupon_eligible ? 'coupon' : 'no_coupon') : 'extracted');
+      const doneDetail = res.is_new_account ? 'fresh account'
+        : res.minutes_checked ? (res.coupon_eligible ? '₹100 coupon' : 'no coupon')
+        : 'extracted';
       this._emit(slot, { phase: 'done', detail: doneDetail });
       releaseOnce(true, doneDetail, true); // success: OTP consumed → no cancel
       return res;