whalibmob 5.6.9 → 5.7.0

package/cli.js

@@ -316,6 +316,9 @@ function ts() {
 let _client  = null;
 let _phone   = null;
 let _sessDir = defaultSessionDir();
+// Set when a failed connect turned out to be a number-form mismatch, so
+// /fixnumber knows what it is fixing without probing the server again.
+let _pendingFix = null;
 let _rl      = null;
 
 // ─── shell help ───────────────────────────────────────────────────────────────
@@ -438,6 +441,7 @@ const HELP = `
   Connection
     /connect    <phone> [sms|pair]           connect to WhatsApp (asks which if unset)
     /pair       <phone> [code]               link to an existing account by 8-digit code
+    /fixnumber                               re-file a session under the number WhatsApp uses
     /disconnect                              disconnect
     /reconnect                              force reconnection
     /session                                show session info
@@ -777,7 +781,22 @@ async function doConnect(phone) {
       out('  checking whether the number is still registered...');
       try {
         const probe = await client.checkSessionAlive();
-        if (probe.alive) {
+
+        if (probe.mismatch) {
+          // The session is filed under a number the server does not use for
+          // this account, so the handshake has been sending a username no
+          // registration matches. Renaming fixes it; re-registering would not.
+          hr();
+          out('  the session is filed under a number WhatsApp does not use');
+          out('    session : +' + probe.current);
+          out('    server  : +' + probe.canonical);
+          hr();
+          out('  WhatsApp knows this account by the second form, so every login');
+          out('  has been sent under a number it has no registration for.');
+          out('');
+          out('  fix it in place:  /fixnumber');
+          out('  (renames the session files, keeps the registration)');
+        } else if (probe.alive) {
           out('  the number IS still registered, but this device was logged out.');
           out('  register it again:  /reg code ' + phone);
         } else if (probe.error) {
@@ -786,6 +805,8 @@ async function doConnect(phone) {
           out('  the registration is gone server-side (' + (probe.status || 'no status') + ').');
           out('  register it again:  /reg code ' + phone);
         }
+        // keep the client around so /fixnumber has a store to work from
+        _pendingFix = probe.mismatch ? { client, probe } : null;
       } catch (probeErr) {
         out('  status check failed: ' + probeErr.message);
       }
@@ -878,6 +899,21 @@ async function handleLine(line) {
         break;
       }
 
+      case '/fixnumber': {
+        if (!_pendingFix) {
+          fail('nothing to fix — run /connect <phone> first and let it report a mismatch');
+          break;
+        }
+        const { client, probe } = _pendingFix;
+        out('renaming session +' + probe.current + ' → +' + probe.canonical + '...');
+        const r = await client.adoptCanonicalNumber(probe.canonical);
+        out('  moved ' + r.files.length + ' file(s)');
+        _pendingFix = null;
+        out('now connect with the number WhatsApp uses:');
+        out('  /connect ' + r.phoneNumber);
+        break;
+      }
+
       case '/pair': {
         const ph = p[1] || _phone;
         if (!ph) {
@@ -1682,9 +1718,18 @@ async function handleLine(line) {
             const finalStore = r.store || store;
             finalStore.registered  = true;
             finalStore.codePending = false;
-            saveStore(finalStore, file);
-            out('registered  session saved to ' + file);
-            out('now run: /connect ' + ph);
+            // Save under the number WhatsApp filed the account as, not the one
+            // that was typed — they differ often enough to matter.
+            const savedPhone = String(finalStore.phoneNumber || ph);
+            const savedFile  = path.join(_sessDir, `${savedPhone}.json`);
+            saveStore(finalStore, savedFile);
+            if (r.canonicalPhoneNumber) {
+              out('note: WhatsApp knows this account as +' + r.canonicalPhoneNumber +
+                  ', not +' + r.typedPhoneNumber);
+              out('      the session is saved under that number');
+            }
+            out('registered  session saved to ' + savedFile);
+            out('now run: /connect ' + savedPhone);
           } else {
             fail('verification failed  ' + JSON.stringify(r));
           }
@@ -2057,7 +2102,7 @@ async function main() {
     }
 
     if (flags.register !== undefined) {
-      const ph   = phone || normalizePhone(pos[0] || '');
+      let   ph   = phone || normalizePhone(pos[0] || '');
       const code = flags.code;
       if (!ph)   { fail('phone number required'); process.exit(1); }
       if (!code) { fail('--code is required');    process.exit(1); }
@@ -2071,9 +2116,16 @@ async function main() {
           const finalStore = r.store || store;
           finalStore.registered  = true;
           finalStore.codePending = false;
-          saveStore(finalStore, file);
-          out('registered  session saved to ' + file);
-          out('run: wa connect ' + ph);
+          const savedPhone = String(finalStore.phoneNumber || ph);
+          const savedFile  = path.join(_sessDir, `${savedPhone}.json`);
+          saveStore(finalStore, savedFile);
+          if (r.canonicalPhoneNumber) {
+            out('note: WhatsApp knows this account as +' + r.canonicalPhoneNumber +
+                ', not +' + r.typedPhoneNumber);
+          }
+          out('registered  session saved to ' + savedFile);
+          out('run: wa connect ' + savedPhone);
+          ph = savedPhone;
         } else {
           out('  status  ' + (r && r.status ? r.status : JSON.stringify(r)));
         }

package/lib/Client.js

@@ -332,7 +332,7 @@ class WhalibmobClient extends EventEmitter {
     socket.on('open',  (sn)  => this._onOpen(sn));
     socket.on('node',  node  => this._onNode(node));
     socket.on('close', ()    => this._onClose());
-    socket.on('error', err   => this.emit('error', err));
+    socket.on('error', err   => this._onSocketError(err));
 
     // Pass reconnect attempt count into the Noise handshake ClientPayload
     this._store.connectAttemptCount = this._reconnectTry;
@@ -478,12 +478,35 @@ class WhalibmobClient extends EventEmitter {
     });
     socket.on('node',  node => this._onNode(node));
     socket.on('close', ()   => this._onClose());
-    socket.on('error', err  => this.emit('error', err));
+    socket.on('error', err  => this._onSocketError(err));
 
     await socket.connect();
     return socket;
   }
 
+  /**
+   * A socket-level error, which includes the server refusing the handshake.
+   *
+   * The refusal arrives here rather than as a <failure> stanza — it happens
+   * before the stream is open, so _handleFailure never sees it and never set
+   * the flag that stops the reconnect. The result was a client that retried a
+   * rejected login every second, forever, printing the same 401 each time.
+   * Anything the handshake marked as a spent session stops the loop here.
+   */
+  _onSocketError(err) {
+    if (err && err.loggedOut) {
+      _whaDbg('[DBG] HANDSHAKE_REJECTED code=' + err.code + ' — not retrying');
+      this._fatal = true;
+      this.emit('auth_failure', {
+        reason: String(err.code || '401'),
+        location: null,
+        loggedOut: true,
+        message: err.message
+      });
+    }
+    this.emit('error', err);
+  }
+
   /**
    * Ask WhatsApp for an 8-character pairing code.
    *
@@ -795,12 +818,85 @@ class WhalibmobClient extends EventEmitter {
     try {
       const res    = await checkIfRegistered(this._store);
       const status = (res && (res.status || res.reason)) || null;
-      return { alive: status === 'ok', status, raw: res };
+
+      // The server answers with the number in its own canonical form. When that
+      // differs from what the session is filed under, the handshake has been
+      // presenting a username no registration matches — which is a 401 with a
+      // completely different remedy from "register again".
+      //
+      // Brazil is where this bites: mobile numbers gained a ninth digit, and
+      // WhatsApp keeps older accounts under the eight-digit form. Type the
+      // number as it appears on the phone and you get a session whose username
+      // the server has never heard of.
+      const canonical = res && res.login ? String(res.login).replace(/\D/g, '') : null;
+      const current   = String(this._store.phoneNumber || '');
+      const mismatch  = !!(canonical && canonical !== current);
+
+      return {
+        alive: status === 'ok',
+        status,
+        canonical,
+        current,
+        mismatch,
+        raw: res
+      };
     } catch (err) {
       return { alive: false, status: null, raw: null, error: err.message };
     }
   }
 
+  /**
+   * Re-file this session under the number the server actually knows it by.
+   *
+   * Renames the session and every file that hangs off it, then reloads. Only
+   * touches the primary (SMS) session — a companion link is keyed by the
+   * account, not by the form of the number.
+   *
+   * @param {string} canonical  the digits the server returned as `login`
+   */
+  async adoptCanonicalNumber(canonical) {
+    canonical = String(canonical || '').replace(/\D/g, '');
+    if (!canonical) throw new Error('adoptCanonicalNumber: no number given');
+    const current = String(this._store && this._store.phoneNumber || '');
+    if (canonical === current) return { renamed: false, phoneNumber: current };
+
+    const wasConnected = this._connected;
+    if (wasConnected) this.disconnect();
+
+    // Every per-session file shares the phone number as its stem.
+    const SUFFIXES = ['.json', '.signal.json', '.sk.json', '.tctoken.json',
+                      '.device-cache.json', '.lid-mapping.json',
+                      '.lid-reverse-mapping.json', '.history.json', '.messages.json'];
+    const moved = [];
+    for (const suffix of SUFFIXES) {
+      const from = path.join(this._sessionDir, current + suffix);
+      const to   = path.join(this._sessionDir, canonical + suffix);
+      if (!fs.existsSync(from)) continue;
+      if (fs.existsSync(to)) {
+        throw new Error('Cannot rename session: ' + canonical + suffix +
+          ' already exists. Move it aside first.');
+      }
+      fs.renameSync(from, to);
+      moved.push(suffix);
+    }
+    if (!moved.length) throw new Error('No session files found for ' + current);
+
+    // The number is inside the store as well as in the filename.
+    const sessionFile = path.join(this._sessionDir, canonical + '.json');
+    const store = loadStore(sessionFile);
+    if (!store) throw new Error('Session file unreadable after rename');
+    store.phoneNumber = canonical;
+    saveStore(store, sessionFile);
+
+    _whaDbg('[DBG] ADOPT_CANONICAL ' + current + ' → ' + canonical +
+      ' files=' + moved.length);
+
+    this._store = store;
+    this._phoneNumber = canonical;
+    this._fatal = false;
+    return { renamed: true, phoneNumber: canonical, files: moved };
+  }
+
   // ─── Reconnection ─────────────────────────────────────────────────────────
 
   _scheduleReconnect() {

package/lib/Registration.js

@@ -912,7 +912,23 @@ async function verifyCode(store, code) {
   const result = await sendRequest('/register', store, waVersion, true, ['code', normalized]);
 
   const status = result.status;
-  if (status === 'ok' || status === 'sent' || status === 'verified') return result;
+  if (status === 'ok' || status === 'sent' || status === 'verified') {
+    // Adopt the number in the server's own form.
+    //
+    // WhatsApp answers with `login`, the canonical digits it filed the account
+    // under, and that is not always what was typed. Brazilian mobiles are the
+    // standing example: they gained a ninth digit, WhatsApp keeps the account
+    // under the eight-digit form, and a session saved under the typed number
+    // sends a username on every connection that matches no registration. The
+    // handshake then fails with 401 and nothing in the message hints at why.
+    const canonical = result.login ? String(result.login).replace(/\D/g, '') : null;
+    if (canonical && canonical !== String(store.phoneNumber)) {
+      result.canonicalPhoneNumber = canonical;
+      result.typedPhoneNumber     = String(store.phoneNumber);
+      store.phoneNumber           = canonical;
+    }
+    return result;
+  }
 
   const reason = result.reason || '';
   if (reason === 'missing') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.6.9",
+  "version": "5.7.0",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto50",
   "main": "index.js",