feat(server): run the WhatsApp channel on whatsapp-web.js (P1.7)
Baileys depends on libsignal (GPL-3.0), which the sidecar bundled. The WhatsApp adapter now drives WhatsApp Web through whatsapp-web.js and keeps its public shape: start, stop, status with the pairing QR, send and inbound text. LocalAuth stores the session as a browser profile in <dataDir>/channels/whatsapp; the old Baileys state is left untouched. The browser comes from whatsapp-browser.ts: CHROME_PATH or PUPPETEER_EXECUTABLE_PATH, then an installed Chrome, Edge or Chromium (Windows, macOS, Linux), then a Chrome for Testing build downloaded on the first start into <dataDir>/browsers, with progress in the status. The root .puppeteerrc.cjs stops npm install from downloading a browser. The sidecar build keeps whatsapp-web.js external: bundled, it fails on __dirname and would inline LGPL node-webpmux. Text only, so ffmpeg is never needed. New dependencies, pinned: whatsapp-web.js 1.34.7 (Apache-2.0) and @puppeteer/browsers 2.13.0 (Apache-2.0). Transitive: puppeteer, puppeteer-core, chromium-bidi, webdriver-bidi-protocol (Apache-2.0), devtools-protocol (BSD-3-Clause), extract-zip (BSD-2-Clause), fluent-ffmpeg and the rest (MIT or ISC), and node-webpmux (LGPL-3.0-or-later, shipped as a separate package; needs the license review). Removed: @whiskeysockets/baileys and libsignal. UF-020 is now Fixed; ADR-0005 records the consequences.
This commit is contained in:
@@ -1,309 +1,119 @@
|
||||
/**
|
||||
* WhatsApp channel adapter — Baileys (unofficial multi-device WebSocket).
|
||||
* WhatsApp channel adapter: whatsapp-web.js, which runs WhatsApp Web in a
|
||||
* headless Chrome, Edge or Chromium through Puppeteer (ADR-0005).
|
||||
*
|
||||
* FOUNDER-ACCEPTED RISK (2026-07-09, docs/plans/CHANNELS-ARC-2026-07-09.md):
|
||||
* Baileys is an UNOFFICIAL client that violates WhatsApp's ToS; accounts can
|
||||
* be banned. The Settings UI must show a prominent ban-risk disclosure and
|
||||
* recommend a secondary number. Do not soften or remove that copy.
|
||||
* The client is unofficial and WhatsApp may block the linked account. The
|
||||
* Settings UI shows that warning and recommends a secondary number; keep it.
|
||||
*
|
||||
* NAT-friendly: Baileys dials OUT to WhatsApp's multi-device WS. Pairing is
|
||||
* QR-scan (like WhatsApp Web): the latest QR string is held in memory and
|
||||
* surfaced through getStatus().qr → /api/channels for the UI to render.
|
||||
* Credentials persist as one encrypted Vault entry so pairing survives
|
||||
* restarts without leaving Baileys session keys as plaintext JSON. Existing
|
||||
* <dataDir>/channels/whatsapp-auth data is migrated once and then removed.
|
||||
* DisconnectReason.loggedOut wipes the Vault entry (re-pair needed).
|
||||
* Pairing is QR-scan like WhatsApp Web: the latest QR string is held in memory
|
||||
* and surfaced through getStatus().qr → /api/channels for the UI to render.
|
||||
* LocalAuth keeps the session as a browser profile in
|
||||
* <dataDir>/channels/whatsapp/session, so pairing survives restarts. When the
|
||||
* phone unlinks the device, whatsapp-web.js deletes that profile and shows a
|
||||
* fresh QR.
|
||||
*
|
||||
* Baileys is loaded via dynamic import so the sidecar boots without paying
|
||||
* its (heavy: libsignal/protobuf) module cost until WhatsApp is enabled.
|
||||
* The browser comes from whatsapp-browser.ts (installed first, a one-time
|
||||
* download otherwise). whatsapp-web.js is loaded with a dynamic import so the
|
||||
* sidecar does not load Puppeteer until WhatsApp is started.
|
||||
*
|
||||
* Text only: media, voice and video messages are ignored, so the ffmpeg that
|
||||
* whatsapp-web.js uses for video stickers is never needed.
|
||||
*/
|
||||
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import type {
|
||||
AuthenticationState, SignalDataSet, SignalDataTypeMap,
|
||||
} from '@whiskeysockets/baileys';
|
||||
import type {
|
||||
ChannelAdapter, ChannelAdapterStatus, ChannelMessage, InboundHandler,
|
||||
} from './types.js';
|
||||
import { chunkText } from './types.js';
|
||||
import { resolveWhatsAppBrowser, WhatsAppBrowserError } from './whatsapp-browser.js';
|
||||
|
||||
/** WhatsApp accepts ~65k; 4000 keeps replies phone-readable. */
|
||||
export const WHATSAPP_MAX_TEXT = 4000;
|
||||
export const WHATSAPP_AUTH_VAULT_KEY = 'channel:whatsapp:auth-state';
|
||||
const BACKOFF_START_MS = 2_000;
|
||||
const BACKOFF_CAP_MS = 60_000;
|
||||
|
||||
export interface WhatsAppAuthVault {
|
||||
get(key: string): { value: string } | null | undefined;
|
||||
has(key: string): boolean;
|
||||
set(key: string, value: string, metadata?: Record<string, unknown>): void;
|
||||
delete(key: string): boolean;
|
||||
}
|
||||
|
||||
interface StoredWhatsAppAuth {
|
||||
version: 1;
|
||||
creds: AuthenticationState['creds'];
|
||||
keys: Array<[string, unknown]>;
|
||||
}
|
||||
|
||||
type BaileysModule = typeof import('@whiskeysockets/baileys');
|
||||
|
||||
const SIGNAL_KEY_TYPES: Array<keyof SignalDataTypeMap> = [
|
||||
'app-state-sync-version',
|
||||
'app-state-sync-key',
|
||||
'sender-key-memory',
|
||||
'sender-key',
|
||||
'identity-key',
|
||||
'lid-mapping',
|
||||
'device-list',
|
||||
'pre-key',
|
||||
'session',
|
||||
'tctoken',
|
||||
];
|
||||
|
||||
function fixLegacyFileName(value: string): string {
|
||||
return value.replace(/\//g, '__').replace(/:/g, '-');
|
||||
}
|
||||
|
||||
function signalStoreKey(type: keyof SignalDataTypeMap, id: string): string {
|
||||
return `${type}:${fixLegacyFileName(id)}`;
|
||||
}
|
||||
|
||||
function parseStoredAuth(raw: string, baileys: BaileysModule): StoredWhatsAppAuth | null {
|
||||
try {
|
||||
const parsed = JSON.parse(raw, baileys.BufferJSON.reviver) as Partial<StoredWhatsAppAuth>;
|
||||
if (parsed.version !== 1 || !parsed.creds || !Array.isArray(parsed.keys)) return null;
|
||||
const keys = parsed.keys.filter((entry): entry is [string, unknown] => (
|
||||
Array.isArray(entry) && entry.length === 2 && typeof entry[0] === 'string'
|
||||
));
|
||||
return { version: 1, creds: parsed.creds, keys };
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function readLegacyAuth(authDir: string, baileys: BaileysModule): StoredWhatsAppAuth | null {
|
||||
const credsPath = path.join(authDir, 'creds.json');
|
||||
if (!fs.existsSync(credsPath)) return null;
|
||||
try {
|
||||
const creds = JSON.parse(
|
||||
fs.readFileSync(credsPath, 'utf8'),
|
||||
baileys.BufferJSON.reviver,
|
||||
) as AuthenticationState['creds'];
|
||||
const keys: Array<[string, unknown]> = [];
|
||||
for (const file of fs.readdirSync(authDir)) {
|
||||
if (file === 'creds.json' || !file.endsWith('.json')) continue;
|
||||
const base = file.slice(0, -'.json'.length);
|
||||
const type = SIGNAL_KEY_TYPES.find(candidate => base.startsWith(`${candidate}-`));
|
||||
if (!type) continue;
|
||||
const id = base.slice(type.length + 1);
|
||||
const value = JSON.parse(
|
||||
fs.readFileSync(path.join(authDir, file), 'utf8'),
|
||||
baileys.BufferJSON.reviver,
|
||||
) as unknown;
|
||||
keys.push([`${type}:${id}`, value]);
|
||||
}
|
||||
return { version: 1, creds, keys };
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/** Baileys AuthenticationState backed entirely by Waggle's encrypted Vault. */
|
||||
export async function useVaultWhatsAppAuthState(
|
||||
vault: WhatsAppAuthVault,
|
||||
legacyAuthDir: string,
|
||||
): Promise<{ state: AuthenticationState; saveCreds: () => void }> {
|
||||
const baileys = await import('@whiskeysockets/baileys');
|
||||
const storedExists = vault.has(WHATSAPP_AUTH_VAULT_KEY);
|
||||
const storedEntry = vault.get(WHATSAPP_AUTH_VAULT_KEY);
|
||||
const stored = storedEntry ? parseStoredAuth(storedEntry.value, baileys) : null;
|
||||
if (storedExists && !stored) {
|
||||
throw new Error('Encrypted WhatsApp auth state is unreadable; pairing state was left untouched');
|
||||
}
|
||||
const legacyExists = fs.existsSync(path.join(legacyAuthDir, 'creds.json'));
|
||||
const legacy = stored ? null : readLegacyAuth(legacyAuthDir, baileys);
|
||||
if (!stored && legacyExists && !legacy) {
|
||||
throw new Error('Legacy WhatsApp auth state could not be migrated; plaintext state was left untouched');
|
||||
}
|
||||
const creds = stored?.creds ?? legacy?.creds ?? baileys.initAuthCreds();
|
||||
const keyStore = new Map<string, unknown>(stored?.keys ?? legacy?.keys ?? []);
|
||||
|
||||
const persist = (): void => {
|
||||
const payload: StoredWhatsAppAuth = {
|
||||
version: 1,
|
||||
creds,
|
||||
keys: [...keyStore.entries()],
|
||||
};
|
||||
vault.set(
|
||||
WHATSAPP_AUTH_VAULT_KEY,
|
||||
JSON.stringify(payload, baileys.BufferJSON.replacer),
|
||||
{ kind: 'whatsapp-auth-state', encryptedAtRest: true },
|
||||
);
|
||||
};
|
||||
|
||||
if (legacy) {
|
||||
// Delete plaintext only after the encrypted write succeeds.
|
||||
persist();
|
||||
fs.rmSync(legacyAuthDir, { recursive: true, force: true });
|
||||
} else if (stored && fs.existsSync(legacyAuthDir)) {
|
||||
// Vault is authoritative; remove any stale plaintext residue.
|
||||
fs.rmSync(legacyAuthDir, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
const state: AuthenticationState = {
|
||||
creds,
|
||||
keys: {
|
||||
get: async <T extends keyof SignalDataTypeMap>(type: T, ids: string[]) => {
|
||||
const result = {} as Record<string, SignalDataTypeMap[T]>;
|
||||
for (const id of ids) {
|
||||
let value = keyStore.get(signalStoreKey(type, id));
|
||||
if (type === 'app-state-sync-key' && value) {
|
||||
value = baileys.proto.Message.AppStateSyncKeyData.fromObject(value as object);
|
||||
}
|
||||
result[id] = value as SignalDataTypeMap[T];
|
||||
}
|
||||
return result;
|
||||
},
|
||||
set: async (data: SignalDataSet) => {
|
||||
const categories = data as Record<string, Record<string, unknown | null> | undefined>;
|
||||
for (const [category, values] of Object.entries(categories)) {
|
||||
if (!values) continue;
|
||||
for (const [id, value] of Object.entries(values)) {
|
||||
const key = signalStoreKey(category as keyof SignalDataTypeMap, id);
|
||||
if (value === null) keyStore.delete(key);
|
||||
else keyStore.set(key, value);
|
||||
}
|
||||
}
|
||||
persist();
|
||||
},
|
||||
},
|
||||
};
|
||||
|
||||
return { state, saveCreds: persist };
|
||||
}
|
||||
|
||||
// This is a server-side state loader, not a React Hook. Use a non-hook alias
|
||||
// internally so the repo-wide React lint rule can distinguish the call site.
|
||||
const loadVaultWhatsAppAuthState = useVaultWhatsAppAuthState;
|
||||
/** Disconnect reasons that mean WhatsApp blocked the account: do not reconnect. */
|
||||
const BLOCKED_STATES = new Set(['TOS_BLOCK', 'SMB_TOS_BLOCK']);
|
||||
const LINKED_MARKER = 'linked';
|
||||
|
||||
/** Status payload extended with the pairing QR (rendered by Settings UI). */
|
||||
export interface WhatsAppStatus extends ChannelAdapterStatus {
|
||||
qr?: string;
|
||||
/** True when registered auth credentials exist in the encrypted Vault. */
|
||||
/** True when a linked session is stored on disk. */
|
||||
paired?: boolean;
|
||||
/** What the adapter is doing before the QR appears (browser lookup or download). */
|
||||
detail?: string;
|
||||
}
|
||||
|
||||
// ── Minimal structural contracts over Baileys (test seam) ──────────────
|
||||
// ── Minimal structural contracts over whatsapp-web.js (test seam) ──────
|
||||
|
||||
interface BaileysEventMap {
|
||||
'connection.update': {
|
||||
connection?: 'close' | 'connecting' | 'open';
|
||||
qr?: string;
|
||||
lastDisconnect?: { error?: unknown };
|
||||
};
|
||||
'messages.upsert': {
|
||||
type: string;
|
||||
messages: Array<{
|
||||
key: { remoteJid?: string | null; fromMe?: boolean | null; id?: string | null; participant?: string | null };
|
||||
pushName?: string | null;
|
||||
message?: {
|
||||
conversation?: string | null;
|
||||
extendedTextMessage?: { text?: string | null } | null;
|
||||
} | null;
|
||||
}>;
|
||||
};
|
||||
'creds.update': unknown;
|
||||
export interface WaMessageLike {
|
||||
from: string;
|
||||
/** Group messages: the participant who wrote it. */
|
||||
author?: string;
|
||||
fromMe: boolean;
|
||||
body: string;
|
||||
/** 'chat' for text; 'image', 'video', 'ptt' (voice), 'audio', … for media. */
|
||||
type: string;
|
||||
isStatus?: boolean;
|
||||
broadcast?: boolean;
|
||||
id?: { _serialized?: string };
|
||||
_data?: { notifyName?: string };
|
||||
}
|
||||
|
||||
export interface WaSocketLike {
|
||||
ev: {
|
||||
on<E extends keyof BaileysEventMap>(event: E, cb: (arg: BaileysEventMap[E]) => void): void;
|
||||
};
|
||||
sendMessage(jid: string, content: { text: string }): Promise<unknown>;
|
||||
end?(err?: Error): void;
|
||||
export interface WaClientLike {
|
||||
on(event: 'qr', listener: (qr: string) => void): unknown;
|
||||
on(event: 'authenticated' | 'ready', listener: () => void): unknown;
|
||||
on(event: 'auth_failure' | 'disconnected', listener: (reason: string) => void): unknown;
|
||||
on(event: 'message', listener: (message: WaMessageLike) => void): unknown;
|
||||
initialize(): Promise<void>;
|
||||
sendMessage(chatId: string, content: string): Promise<unknown>;
|
||||
destroy(): Promise<void>;
|
||||
}
|
||||
|
||||
export type WaSocketFactory = (
|
||||
vault: WhatsAppAuthVault,
|
||||
legacyAuthDir: string,
|
||||
onAuthError: (error: unknown) => void,
|
||||
) => Promise<WaSocketLike>;
|
||||
export type WaClientFactory = (opts: { authDir: string; executablePath: string }) => Promise<WaClientLike>;
|
||||
|
||||
interface BaileysLogger {
|
||||
level: string;
|
||||
child(fields: Record<string, unknown>): BaileysLogger;
|
||||
trace(value: unknown, message?: string): void;
|
||||
debug(value: unknown, message?: string): void;
|
||||
info(value: unknown, message?: string): void;
|
||||
warn(value: unknown, message?: string): void;
|
||||
error(value: unknown, message?: string): void;
|
||||
}
|
||||
export type WaBrowserResolver = (onProgress: (percent: number) => void) => Promise<string>;
|
||||
|
||||
const silentBaileysLogger: BaileysLogger = {
|
||||
level: 'silent',
|
||||
child: () => silentBaileysLogger,
|
||||
trace: () => undefined,
|
||||
debug: () => undefined,
|
||||
info: () => undefined,
|
||||
warn: () => undefined,
|
||||
error: () => undefined,
|
||||
};
|
||||
|
||||
/** Production factory — real Baileys, dynamically imported. */
|
||||
async function defaultWaSocketFactory(
|
||||
vault: WhatsAppAuthVault,
|
||||
legacyAuthDir: string,
|
||||
onAuthError: (error: unknown) => void,
|
||||
): Promise<WaSocketLike> {
|
||||
const baileys = await import('@whiskeysockets/baileys');
|
||||
const { state, saveCreds } = await loadVaultWhatsAppAuthState(vault, legacyAuthDir);
|
||||
const sock = baileys.makeWASocket({
|
||||
auth: state,
|
||||
logger: silentBaileysLogger,
|
||||
// No terminal QR — the Settings UI renders it from getStatus().qr.
|
||||
printQRInTerminal: false,
|
||||
syncFullHistory: false,
|
||||
/** Production factory: real whatsapp-web.js, dynamically imported. */
|
||||
async function defaultClientFactory(opts: { authDir: string; executablePath: string }): Promise<WaClientLike> {
|
||||
const { Client, LocalAuth } = (await import('whatsapp-web.js')).default;
|
||||
return new Client({
|
||||
authStrategy: new LocalAuth({ dataPath: opts.authDir }),
|
||||
// The default cache path is relative to the process cwd.
|
||||
webVersionCache: { type: 'local', path: path.join(opts.authDir, 'web-cache') },
|
||||
puppeteer: {
|
||||
executablePath: opts.executablePath,
|
||||
headless: true,
|
||||
// Puppeteer's own handlers would exit the process on Ctrl-C. The sidecar
|
||||
// shuts down itself and closes the browser through stop().
|
||||
handleSIGINT: false,
|
||||
handleSIGTERM: false,
|
||||
handleSIGHUP: false,
|
||||
},
|
||||
});
|
||||
sock.ev.on('creds.update', () => {
|
||||
try {
|
||||
saveCreds();
|
||||
} catch (error) {
|
||||
onAuthError(error);
|
||||
}
|
||||
});
|
||||
return sock as unknown as WaSocketLike;
|
||||
}
|
||||
|
||||
/** Extract the Baileys disconnect status code (boom-style error). */
|
||||
export function disconnectStatusCode(lastDisconnect?: { error?: unknown }): number | undefined {
|
||||
const err = lastDisconnect?.error as { output?: { statusCode?: number } } | undefined;
|
||||
return err?.output?.statusCode;
|
||||
}
|
||||
|
||||
const LOGGED_OUT = 401; // DisconnectReason.loggedOut
|
||||
|
||||
export interface WhatsAppAdapterOptions {
|
||||
/** Channels data dir, used only to migrate/remove legacy plaintext state. */
|
||||
/** Waggle data dir; the session lives in <dataDir>/channels/whatsapp. */
|
||||
dataDir: string;
|
||||
/** Encrypted store for all Baileys credentials and signal keys. */
|
||||
vault: WhatsAppAuthVault;
|
||||
onMessage: InboundHandler;
|
||||
log: { info: (msg: string) => void; warn: (msg: string) => void };
|
||||
/** Test seam: finds or downloads the browser. */
|
||||
browserResolver?: WaBrowserResolver;
|
||||
/** Test seam. */
|
||||
socketFactory?: WaSocketFactory;
|
||||
clientFactory?: WaClientFactory;
|
||||
backoffCapMs?: number;
|
||||
}
|
||||
|
||||
export class WhatsAppAdapter implements ChannelAdapter {
|
||||
readonly platform = 'whatsapp' as const;
|
||||
|
||||
private readonly legacyAuthDir: string;
|
||||
private readonly vault: WhatsAppAuthVault;
|
||||
private readonly authDir: string;
|
||||
private readonly onMessage: InboundHandler;
|
||||
private readonly log: WhatsAppAdapterOptions['log'];
|
||||
private readonly socketFactory: WaSocketFactory;
|
||||
private readonly browserResolver: WaBrowserResolver;
|
||||
private readonly clientFactory: WaClientFactory;
|
||||
private readonly backoffCap: number;
|
||||
|
||||
private running = false;
|
||||
@@ -311,33 +121,46 @@ export class WhatsAppAdapter implements ChannelAdapter {
|
||||
private lastError: string | undefined;
|
||||
private lastActivityAt: number | undefined;
|
||||
private qr: string | undefined;
|
||||
private sock: WaSocketLike | null = null;
|
||||
private detail: string | undefined;
|
||||
private client: WaClientLike | null = null;
|
||||
private reconnectTimer: NodeJS.Timeout | null = null;
|
||||
private backoff: number;
|
||||
/** Bumped by stop() so a connect still awaiting the browser can bail out. */
|
||||
private generation = 0;
|
||||
|
||||
constructor(opts: WhatsAppAdapterOptions) {
|
||||
this.legacyAuthDir = path.join(opts.dataDir, 'channels', 'whatsapp-auth');
|
||||
this.vault = opts.vault;
|
||||
this.authDir = path.join(opts.dataDir, 'channels', 'whatsapp');
|
||||
this.onMessage = opts.onMessage;
|
||||
this.log = opts.log;
|
||||
this.socketFactory = opts.socketFactory ?? defaultWaSocketFactory;
|
||||
this.browserResolver = opts.browserResolver ?? (async onProgress => (
|
||||
await resolveWhatsAppBrowser({ dataDir: opts.dataDir, onProgress })
|
||||
).executablePath);
|
||||
this.clientFactory = opts.clientFactory ?? defaultClientFactory;
|
||||
this.backoffCap = opts.backoffCapMs ?? BACKOFF_CAP_MS;
|
||||
this.backoff = Math.min(BACKOFF_START_MS, this.backoffCap);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns once the connection attempt is under way. Finding or downloading
|
||||
* the browser and loading WhatsApp Web continue in the background and show
|
||||
* up in getStatus().
|
||||
*/
|
||||
async start(): Promise<void> {
|
||||
if (this.running) return;
|
||||
this.running = true;
|
||||
this.lastError = undefined;
|
||||
await this.connect();
|
||||
void this.connect();
|
||||
}
|
||||
|
||||
async stop(): Promise<void> {
|
||||
this.running = false;
|
||||
this.generation += 1;
|
||||
if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
|
||||
this.teardownSocket();
|
||||
this.reconnectTimer = null;
|
||||
this.connected = false;
|
||||
this.qr = undefined;
|
||||
this.detail = undefined;
|
||||
await this.teardownClient();
|
||||
}
|
||||
|
||||
getStatus(): WhatsAppStatus {
|
||||
@@ -348,98 +171,160 @@ export class WhatsAppAdapter implements ChannelAdapter {
|
||||
lastError: this.lastError,
|
||||
lastActivityAt: this.lastActivityAt,
|
||||
qr: this.qr,
|
||||
paired: this.hasPersistedAuth(),
|
||||
paired: this.hasLinkedSession(),
|
||||
detail: this.detail,
|
||||
};
|
||||
}
|
||||
|
||||
async send(chatId: string, text: string): Promise<void> {
|
||||
if (!this.sock) throw new Error('WhatsApp is not connected');
|
||||
const client = this.client;
|
||||
if (!client || !this.connected) throw new Error('WhatsApp is not connected');
|
||||
for (const chunk of chunkText(text, WHATSAPP_MAX_TEXT)) {
|
||||
await this.sock.sendMessage(chatId, { text: chunk });
|
||||
await client.sendMessage(chatId, chunk);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Connection lifecycle ─────────────────────────────────────────────
|
||||
|
||||
private async connect(): Promise<void> {
|
||||
const generation = this.generation;
|
||||
const current = () => this.running && generation === this.generation;
|
||||
|
||||
let executablePath: string;
|
||||
try {
|
||||
const sock = await this.socketFactory(this.vault, this.legacyAuthDir, error => {
|
||||
const message = error instanceof Error ? error.message : String(error);
|
||||
this.lastError = `Could not save encrypted WhatsApp session: ${message}`;
|
||||
this.log.warn(`[whatsapp] ${this.lastError}`);
|
||||
});
|
||||
this.sock = sock;
|
||||
|
||||
sock.ev.on('connection.update', update => {
|
||||
if (update.qr) {
|
||||
this.qr = update.qr;
|
||||
this.log.info('[whatsapp] pairing QR refreshed — scan it from Settings → Channels');
|
||||
}
|
||||
if (update.connection === 'open') {
|
||||
this.connected = true;
|
||||
this.qr = undefined;
|
||||
this.lastError = undefined;
|
||||
this.backoff = Math.min(BACKOFF_START_MS, this.backoffCap);
|
||||
this.lastActivityAt = Date.now();
|
||||
this.log.info('[whatsapp] connected');
|
||||
}
|
||||
if (update.connection === 'close') {
|
||||
const code = disconnectStatusCode(update.lastDisconnect);
|
||||
if (code === LOGGED_OUT) {
|
||||
// Device unlinked from the phone — credentials are dead. Wipe so
|
||||
// the next start shows a fresh QR instead of a reconnect loop.
|
||||
this.wipeAuthState();
|
||||
this.handleDrop('logged out — re-pair via QR', false);
|
||||
} else {
|
||||
this.handleDrop(`connection closed (code ${code ?? 'unknown'})`, true);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
sock.ev.on('messages.upsert', upsert => {
|
||||
if (upsert.type !== 'notify') return;
|
||||
for (const raw of upsert.messages) {
|
||||
const msg = this.normalize(raw);
|
||||
if (!msg) continue;
|
||||
this.lastActivityAt = Date.now();
|
||||
void this.onMessage(msg).catch(e => {
|
||||
this.log.warn(`[whatsapp] inbound handler failed: ${e instanceof Error ? e.message : e}`);
|
||||
});
|
||||
}
|
||||
this.detail = 'Looking for Chrome, Edge or Chromium';
|
||||
executablePath = await this.browserResolver(percent => {
|
||||
if (current()) this.detail = `Downloading a browser for WhatsApp (about 170 MB): ${percent}%`;
|
||||
});
|
||||
} catch (e: unknown) {
|
||||
this.handleDrop(e instanceof Error ? e.message : String(e), true);
|
||||
if (!current()) return;
|
||||
const message = e instanceof Error ? e.message : String(e);
|
||||
// A missing browser needs the user to act, so do not retry on a timer.
|
||||
this.handleDrop(message, !(e instanceof WhatsAppBrowserError));
|
||||
return;
|
||||
}
|
||||
if (!current()) return;
|
||||
|
||||
let client: WaClientLike;
|
||||
try {
|
||||
this.detail = 'Starting the browser';
|
||||
client = await this.clientFactory({ authDir: this.authDir, executablePath });
|
||||
} catch (e: unknown) {
|
||||
if (current()) this.handleDrop(e instanceof Error ? e.message : String(e), true);
|
||||
return;
|
||||
}
|
||||
if (!current()) {
|
||||
void client.destroy().catch(() => undefined);
|
||||
return;
|
||||
}
|
||||
this.client = client;
|
||||
this.attach(client);
|
||||
|
||||
try {
|
||||
await client.initialize();
|
||||
} catch (e: unknown) {
|
||||
if (this.client !== client) return;
|
||||
this.handleDrop(`browser session failed: ${e instanceof Error ? e.message : String(e)}`, true);
|
||||
}
|
||||
}
|
||||
|
||||
private normalize(raw: BaileysEventMap['messages.upsert']['messages'][number]): ChannelMessage | null {
|
||||
const jid = raw.key.remoteJid;
|
||||
if (!jid || raw.key.fromMe) return null;
|
||||
if (jid === 'status@broadcast') return null;
|
||||
const text = raw.message?.conversation ?? raw.message?.extendedTextMessage?.text;
|
||||
if (!text) return null;
|
||||
// In groups the author is key.participant; in DMs it's the chat jid.
|
||||
const senderId = raw.key.participant ?? jid;
|
||||
private attach(client: WaClientLike): void {
|
||||
const live = () => this.client === client;
|
||||
|
||||
client.on('qr', qr => {
|
||||
if (!live()) return;
|
||||
this.qr = qr;
|
||||
this.detail = undefined;
|
||||
this.log.info('[whatsapp] pairing QR refreshed; scan it from Settings > Channels');
|
||||
});
|
||||
|
||||
client.on('authenticated', () => {
|
||||
if (!live()) return;
|
||||
this.qr = undefined;
|
||||
this.detail = 'Linked. Loading WhatsApp';
|
||||
});
|
||||
|
||||
client.on('ready', () => {
|
||||
if (!live()) return;
|
||||
this.connected = true;
|
||||
this.qr = undefined;
|
||||
this.detail = undefined;
|
||||
this.lastError = undefined;
|
||||
this.backoff = Math.min(BACKOFF_START_MS, this.backoffCap);
|
||||
this.lastActivityAt = Date.now();
|
||||
this.markLinked(true);
|
||||
this.log.info('[whatsapp] connected');
|
||||
});
|
||||
|
||||
client.on('auth_failure', reason => {
|
||||
if (!live()) return;
|
||||
this.handleDrop(`stored session rejected (${reason}); start WhatsApp again to re-pair via QR`, false);
|
||||
// The stored session cannot be restored. Delete the profile once the
|
||||
// browser has closed so the next start shows a fresh QR.
|
||||
void client.destroy().catch(() => undefined).then(() => this.wipeSession());
|
||||
});
|
||||
|
||||
client.on('disconnected', reason => {
|
||||
if (!live()) return;
|
||||
if (reason === 'LOGOUT') {
|
||||
// Unlinked from the phone. whatsapp-web.js has already deleted the
|
||||
// profile and reloads WhatsApp Web, which emits a fresh QR.
|
||||
this.connected = false;
|
||||
this.markLinked(false);
|
||||
this.lastError = 'logged out from the phone; scan the new QR to link again';
|
||||
this.log.warn(`[whatsapp] ${this.lastError}`);
|
||||
return;
|
||||
}
|
||||
if (BLOCKED_STATES.has(reason)) {
|
||||
this.handleDrop(`WhatsApp blocked this account (${reason})`, false);
|
||||
return;
|
||||
}
|
||||
this.handleDrop(`disconnected (${reason})`, true);
|
||||
});
|
||||
|
||||
client.on('message', raw => {
|
||||
if (!live()) return;
|
||||
const msg = this.normalize(raw);
|
||||
if (!msg) return;
|
||||
this.lastActivityAt = Date.now();
|
||||
void this.onMessage(msg).catch(e => {
|
||||
this.log.warn(`[whatsapp] inbound handler failed: ${e instanceof Error ? e.message : e}`);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
private normalize(raw: WaMessageLike): ChannelMessage | null {
|
||||
const chatId = raw.from;
|
||||
if (!chatId || raw.fromMe || raw.isStatus || raw.broadcast) return null;
|
||||
if (chatId === 'status@broadcast') return null;
|
||||
if (raw.type !== 'chat') {
|
||||
this.log.info(`[whatsapp] ignored a ${raw.type} message: the WhatsApp channel handles text only`);
|
||||
return null;
|
||||
}
|
||||
if (!raw.body) return null;
|
||||
return {
|
||||
platform: 'whatsapp',
|
||||
chatId: jid,
|
||||
senderId,
|
||||
senderName: raw.pushName ?? undefined,
|
||||
text,
|
||||
messageId: raw.key.id ?? undefined,
|
||||
chatId,
|
||||
// In groups the author is the participant; in DMs it is the chat id.
|
||||
senderId: raw.author ?? chatId,
|
||||
senderName: raw._data?.notifyName ?? undefined,
|
||||
text: raw.body,
|
||||
messageId: raw.id?._serialized ?? undefined,
|
||||
};
|
||||
}
|
||||
|
||||
private handleDrop(reason: string, reconnect: boolean): void {
|
||||
this.teardownSocket();
|
||||
void this.teardownClient();
|
||||
this.connected = false;
|
||||
this.qr = undefined;
|
||||
this.detail = undefined;
|
||||
if (!this.running) return;
|
||||
this.lastError = reason;
|
||||
if (!reconnect) {
|
||||
this.log.warn(`[whatsapp] ${reason}`);
|
||||
return;
|
||||
}
|
||||
this.log.warn(`[whatsapp] dropped (${reason}) — reconnecting in ${this.backoff}ms`);
|
||||
this.log.warn(`[whatsapp] dropped (${reason}); reconnecting in ${this.backoff}ms`);
|
||||
this.reconnectTimer = setTimeout(() => {
|
||||
void this.connect();
|
||||
}, this.backoff);
|
||||
@@ -447,33 +332,39 @@ export class WhatsAppAdapter implements ChannelAdapter {
|
||||
this.backoff = Math.min(this.backoff * 2, this.backoffCap);
|
||||
}
|
||||
|
||||
private wipeAuthState(): void {
|
||||
private markLinked(linked: boolean): void {
|
||||
const marker = path.join(this.authDir, LINKED_MARKER);
|
||||
try {
|
||||
this.vault.delete(WHATSAPP_AUTH_VAULT_KEY);
|
||||
fs.rmSync(this.legacyAuthDir, { recursive: true, force: true });
|
||||
} catch (e: unknown) {
|
||||
this.log.warn(`[whatsapp] failed to clear auth state: ${e instanceof Error ? e.message : e}`);
|
||||
}
|
||||
}
|
||||
|
||||
private hasPersistedAuth(): boolean {
|
||||
const entry = this.vault.get(WHATSAPP_AUTH_VAULT_KEY);
|
||||
if (entry) {
|
||||
try {
|
||||
const parsed = JSON.parse(entry.value) as { creds?: { registered?: boolean } };
|
||||
return parsed.creds?.registered === true;
|
||||
} catch {
|
||||
return false;
|
||||
if (linked) {
|
||||
fs.mkdirSync(this.authDir, { recursive: true });
|
||||
fs.writeFileSync(marker, new Date().toISOString(), 'utf8');
|
||||
} else {
|
||||
fs.rmSync(marker, { force: true });
|
||||
}
|
||||
} catch (e: unknown) {
|
||||
this.log.warn(`[whatsapp] failed to update the linked-session marker: ${e instanceof Error ? e.message : e}`);
|
||||
}
|
||||
// Compatibility during the one-time migration window.
|
||||
return fs.existsSync(path.join(this.legacyAuthDir, 'creds.json'));
|
||||
}
|
||||
|
||||
private teardownSocket(): void {
|
||||
private wipeSession(): void {
|
||||
this.markLinked(false);
|
||||
try {
|
||||
this.sock?.end?.(undefined);
|
||||
} catch { /* already closed */ }
|
||||
this.sock = null;
|
||||
fs.rmSync(path.join(this.authDir, 'session'), { recursive: true, force: true, maxRetries: 4 });
|
||||
} catch (e: unknown) {
|
||||
this.log.warn(`[whatsapp] failed to clear the session: ${e instanceof Error ? e.message : e}`);
|
||||
}
|
||||
}
|
||||
|
||||
private hasLinkedSession(): boolean {
|
||||
return fs.existsSync(path.join(this.authDir, LINKED_MARKER))
|
||||
&& fs.existsSync(path.join(this.authDir, 'session'));
|
||||
}
|
||||
|
||||
private async teardownClient(): Promise<void> {
|
||||
const client = this.client;
|
||||
this.client = null;
|
||||
try {
|
||||
await client?.destroy();
|
||||
} catch { /* browser already closed */ }
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user