scripter-x 1.0.18 → 1.0.20

package/package.json

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

package/src/commands.js

@@ -10,7 +10,7 @@ import * as kuku from './providers/kuku.js';
 import * as zepto from './providers/zepto.js';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
-import { mkdirSync, writeFileSync, existsSync } from 'node:fs';
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
 import { Worker } from './worker.js';
 import { RunController } from './controller.js';
 import { STATUS } from './theme.js';
@@ -221,6 +221,59 @@ export async function run(io, api, args = {}) {
   if (worker.logPath) io.print(`  ◉ log saved to: ${worker.logPath}`);
 }
 
+// ── recheck: re-validate Minutes status of an EXISTING session JSON, locally ──
+// FK blocks server IPs, so the Minutes check must run here (residential IP). Takes
+// a file (array of sessions, OR our {session:{...}} export shape), re-checks each
+// account's live Minutes orders, and re-splits into correct -minutes-free /
+// -minutes-used files with real stats + the actual order ids.
+export async function recheck(io, _api, args = {}) {
+  // one-shot puts the positional path in action/campaign; interactive may pass file/_
+  const src = args.file || args._?.[0] || args.action || args.campaign;
+  if (!src || !existsSync(src)) throw new Error('usage: recheck <sessions.json>');
+  const raw = JSON.parse(readFileSync(src, 'utf8'));
+  const list = Array.isArray(raw) ? raw : (raw.accounts || raw.sessions || [raw]);
+  // normalize each entry to a flat FK session object
+  const sessions = list.map((e) => (e && e.session && typeof e.session === 'object' ? e.session : e)).filter(Boolean);
+  if (!sessions.length) throw new Error('no sessions found in file');
+
+  const { FlipkartLogin } = await import('./flipkart.js');
+  const fk = new FlipkartLogin();
+
+  io.print(`  ◉ re-checking ${sessions.length} account(s) locally (your IP) …`);
+  const free = [], used = [], errored = [];
+  for (let i = 0; i < sessions.length; i++) {
+    const s = sessions[i];
+    const mob = s.mobileNo || s.mobile || `#${i + 1}`;
+    try {
+      const m = await fk.checkMinutes(s);
+      if (m.eligible) { free.push(s); io.print(`  🟢 ${mob} — minutes-free (₹100 coupon)`); }
+      else {
+        used.push(s);
+        io.print(`  🔴 ${mob} — ${m.count} minutes order(s): ${m.orders.map((o) => o.orderId).join(', ')}`, 'danger');
+      }
+    } catch (e) { errored.push(s); io.print(`  ! ${mob} — check failed: ${e.message}`, 'danger'); }
+  }
+
+  // write corrected files next to the source
+  const dir = dirname(src);
+  const stem = src.split(/[/\\]/).pop().replace(/\.json$/i, '').replace(/-minutes-(free|used|unchecked)$/i, '');
+  const write = (suffix, arr) => {
+    if (!arr.length) return null;
+    const dest = join(dir, `${stem}-rechecked${suffix}.json`);
+    writeFileSync(dest, JSON.stringify(arr, null, 2));
+    return dest;
+  };
+  const fFree = write('-minutes-free', free);
+  const fUsed = write('-minutes-used', used);
+  const fErr = write('-errors', errored);
+
+  io.print('');
+  io.print(`  ✓ stats: 🟢 ${free.length} minutes-free · 🔴 ${used.length} minutes-used · ! ${errored.length} errors`);
+  if (fFree) io.print(`     🟢 minutes-free → ${fFree}`, 'accent');
+  if (fUsed) io.print(`     🔴 minutes-used → ${fUsed}`, 'accent');
+  if (fErr) io.print(`     ! errors → ${fErr}`, 'accent');
+}
+
 // ── zepto: local OTP login → extract session to a ZAUTH1 envelope file ──
 // Dead-simple, no backend: enter a number → we SMS an OTP locally → enter the
 // code → we verify, build the ZAUTH1 envelope, and write {phone}-{timestamp}.txt.
@@ -549,7 +602,7 @@ export async function configCmd(io, _api, args = {}) {
 }
 
 export function help(io) {
-  io.print('  commands: run · zepto · campaigns · export · balance · creds · stop · delete · whoami · config · update · logout · exit');
+  io.print('  commands: run · zepto · recheck · campaigns · export · balance · creds · stop · delete · whoami · config · update · logout · exit');
 }
 
 export async function update(io) {
@@ -562,6 +615,6 @@ export async function update(io) {
 
 // dispatch table used by the interactive shell
 export const REGISTRY = {
-  run, zepto: zeptoCmd, campaigns, export: exportCmd, balance, creds, stop, delete: del,
+  run, zepto: zeptoCmd, recheck, campaigns, export: exportCmd, balance, creds, stop, delete: del,
   whoami, login, logout, config: configCmd, update, help,
 };

package/src/flipkart.js

@@ -29,6 +29,40 @@ const nativeUa = (vid) =>
   `Mozilla/5.0 (Linux; Android 13; sdk_gphone64_arm64 Build/TE1A.240213.009) ` +
   `FKUA/Retail/3130902/Android/Mobile (Google/sdk_gphone64_arm64/${(vid || '').toLowerCase()})`;
 
+// Parse a MY_ORDER_PAGE response and return ONLY genuine Flipkart-Minutes orders.
+// An order is a slot whose widget is an ORDER CARD (SUPER_WIDGET +
+// ORDER_CARD_SUPER_WIDGET_TRANSFORMER); its id is widget.params.trackingParams.orderId
+// (exactly one per card). It's a MINUTES order iff the card's redirect carries
+// queryParam.hyperlocal === "true" — Grocery/Kilos/memberships are NOT hyperlocal,
+// so they're excluded even in an unfiltered response. (Verified against captured
+// ground-truth: 0-Minutes accounts → 0, 1/2-Minutes accounts → exact match.)
+// Returns [{ orderId, title, status }].
+export function parseMinutesOrders(text) {
+  let env;
+  try { env = JSON.parse(text); } catch { return []; }
+  const resp = (env && env.RESPONSE) || env || {};
+  const slots = Array.isArray(resp.slots) ? resp.slots : [];
+  const seen = new Set();
+  const out = [];
+  for (const s of slots) {
+    const w = (s && s.widget) || {};
+    if (w.type !== 'SUPER_WIDGET' || w.transformerProvider !== 'ORDER_CARD_SUPER_WIDGET_TRANSFORMER') continue;
+    const tp = (w.params && w.params.trackingParams) || {};
+    const orderId = tp.orderId;
+    if (!orderId || seen.has(orderId)) continue;
+    let isMinutes = false, title = '';
+    try {
+      const rc = w.data.subWidgets[0].data.buttons.renderableComponents[0];
+      isMinutes = rc.action.nonWidgetizeRedirection.queryParam.hyperlocal === 'true';
+      title = (rc.value && rc.value.subText) || '';
+    } catch { /* malformed card → not a counted Minutes order */ }
+    if (!isMinutes) continue;
+    seen.add(orderId);
+    out.push({ orderId, title, status: tp.orderStatus || '' });
+  }
+  return out;
+}
+
 // Parse a fetch Response's set-cookie headers into a {name:value} map.
 function parseCookies(res, jar) {
   // Node fetch exposes combined set-cookie via getSetCookie() (undici).
@@ -138,7 +172,9 @@ export class FlipkartLogin {
     };
   }
 
-  async checkMinutes(session) {
+  // One MY_ORDER_PAGE / HYPERLOCAL fetch on a given DC. `withRT` attaches the refresh
+  // token so a 206 "AT expired" can be recovered in-place. Returns { status, text }.
+  async _fetchOrderPage(session, dc, withRT) {
     await throttle.wait();
     const body = {
       requestContext: { type: 'MY_ORDER_PAGE', pageView: '', queryTime: '', cxTenant: 'cs',
@@ -148,19 +184,50 @@ export class FlipkartLogin {
         paginatedFetch: false, pageNumber: 1, fetchAllPages: false, networkSpeed: 0,
         trackingContext: null, fetchSeoData: false },
       locationContext: { pincode: '' } };
-    const res = await fetch(`${NATIVE_HOST}/4/page/fetch`, {
-      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","pageUri":"questContext"}',
-        at: session.at || '', sn: session.sn || '',
-        secureToken: session.secureToken || '', secureCookie: session.secureCookie || '',
-      },
-    });
-    const text = await res.text();
-    const count = (text.match(/OD\d{15,}/g) || []).length;
-    return count === 0; // no orders ⇒ coupon available
+    const host = `https://${dc}.rome.api.flipkart.net`;
+    const at = session.at || '';
+    const headers = {
+      'User-Agent': 'okhttp/4.9.2', 'X-User-Agent': nativeUa(session.visitId || this.vid),
+      'Content-Type': 'application/json; charset=UTF-8',
+      'x-request-metaInfo': '{"actionType":"LOGIN","pageUri":"questContext"}',
+      at, sn: session.sn || '',
+      secureToken: session.secureToken || '', secureCookie: session.secureCookie || '',
+      Cookie: `ud=${session.ud || ''}`,
+    };
+    if (withRT && session.rt) headers.rt = session.rt;
+    const res = await fetch(`${host}/4/page/fetch`, { method: 'POST', body: JSON.stringify(body), headers });
+    return { status: res.status, text: await res.text() };
+  }
+
+  // Robust FK Minutes check. Handles 206 (AT-expired → resend with rt) and 406
+  // (DC change → retry on home DC), then parses ORDER CARDS (not a blind regex)
+  // and gates each on its per-card `hyperlocal` flag — so non-Minutes orders
+  // (Grocery/Kilos/memberships) and page chrome never count.
+  // Returns { eligible, count, orders:[{orderId,title,status}] }.
+  async checkMinutes(session) {
+    let dc = 2;
+    const triedDC = { 2: true };
+    let r = await this._fetchOrderPage(session, dc, false);
+
+    // 206 "AT expired" → resend with rt on the same DC
+    if (r.status === 206 || /AT expired/i.test(r.text)) {
+      r = await this._fetchOrderPage(session, dc, true);
+      // adopt the refreshed token for any follow-up DC retry
+      try { const e = JSON.parse(r.text); if (e?.SESSION?.at) session = { ...session, at: e.SESSION.at }; } catch { /* */ }
+    }
+    // 406 DC change → {RESPONSE:{id:"<dc>"}} → retry on the home DC
+    if (r.status === 406) {
+      let id = null;
+      try { const e = JSON.parse(r.text); id = parseInt(e?.RESPONSE?.id || e?.id, 10); } catch { /* */ }
+      if (id >= 1 && !triedDC[id]) {
+        dc = id; triedDC[id] = true;
+        r = await this._fetchOrderPage(session, dc, false);
+        if (r.status === 206 || /AT expired/i.test(r.text)) r = await this._fetchOrderPage(session, dc, true);
+      }
+    }
+
+    const orders = parseMinutesOrders(r.text);
+    return { eligible: orders.length === 0, count: orders.length, orders };
   }
 
   // ─── Email attach (FK-5/6/7) — on the EMAIL host (2.rome.api.flipkart.com) ──────

package/src/index.js

@@ -54,6 +54,8 @@ const HELP = `${paint.bold('scripterx')} — local Flipkart session extractor
        --auto | --manual    --count N  --concurrency N  --out <file|dir>  --cert <64hex>
        --number <10-digit>  --otp <code>
        (envelope keyed to ZeptoAuthManager cert; override with --cert or $ZAUTH_CERT_SHA)
+  scripterx recheck <file>  re-validate Minutes status of a session JSON, locally (your IP)
+       → re-splits into corrected -minutes-free / -minutes-used files + stats
   scripterx campaigns | export [name] | balance | creds | stop | delete | whoami | config
   scripterx --version`;
 
@@ -104,7 +106,7 @@ async function main() {
   }
 
   // ── one-shot mode ──
-  const map = { run: 'run', zepto: 'zepto', campaigns: 'campaigns', export: 'export', balance: 'balance',
+  const map = { run: 'run', zepto: 'zepto', recheck: 'recheck', campaigns: 'campaigns', export: 'export', balance: 'balance',
     creds: 'creds', stop: 'stop', delete: 'delete', whoami: 'whoami', login: 'login',
     logout: 'logout', config: 'config', update: 'update', help: 'help' };
   const fnName = map[cmd];

package/src/worker.js

@@ -75,6 +75,11 @@ export class Worker {
         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,
+        // pack the local Minutes order count + ids into minutes_note (free-text the
+        // server already stores) so stats/export survive the round-trip.
+        minutes_note: res.minutes_checked
+          ? (res.minutes_order_count ? `${res.minutes_order_count} minutes order(s): ${(res.minutes_orders || []).map((o) => o.orderId).join(',')}` : 'no minutes orders')
+          : undefined,
         linked_email: res.linked_email ?? undefined,
         email_linked: res.email_linked ?? undefined,
         email_reason: res.email_reason ?? undefined,
@@ -216,8 +221,15 @@ export class Worker {
       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;
+          const m = await fk.checkMinutes(session);
+          // checkMinutes now returns { eligible, count, orders }; tolerate an old boolean too.
+          const eligible = typeof m === 'boolean' ? m : m.eligible;
+          res.minutes_checked = true;
+          res.coupon_eligible = eligible;
+          res.has_minutes_order = !eligible;
+          res.minutes_order_count = typeof m === 'boolean' ? (eligible ? 0 : 1) : m.count;
+          res.minutes_orders = typeof m === 'boolean' ? [] : (m.orders || []);
+          this._emit(slot, { phase: 'minutes', detail: eligible ? 'minutes-free (₹100 coupon)' : `has ${res.minutes_order_count} minutes order(s)` });
         } catch { /* non-fatal */ }
       }