@oxidezap/baileyrs 0.2.12 → 0.3.0

package/lib/Socket/index.js

@@ -31,6 +31,7 @@ import { makeBridgeClientOwner } from './bridge-client-owner.js';
 import { warnUnsupportedConfig } from './unsupported-config.js';
 import { wrapBridgeClient } from './bridge-error-boundary.js';
 import { makeTerminalCloseReporter } from './terminal-close-reporter.js';
+import { mapConnectFailureToDisconnect } from './terminal-close.js';
 import { makeEventHandlers } from './events.js';
 import { makeGroupMethods } from './groups.js';
 import { makeInternalMethods, makeUnexpectedErrorReporter } from './internals.js';
@@ -43,6 +44,7 @@ import { makeServerQueryMethods } from './server-queries.js';
 import { makeProfileMethods } from './profile.js';
 import { mapReachoutTimelock } from './reachout.js';
 import { makeHttpClient, makeTransport } from './transport.js';
+import { makeWithClient } from './client-operations.js';
 import { makeUSyncMethods } from './usync.js';
 let wasmInitialized = false;
 /**
@@ -71,6 +73,29 @@ const browserToPlatformType = (browser) => {
             return 'CHROME';
     }
 };
+const COMPLETION_FAILURE_CODES = new Map([
+    ['Generic', 400],
+    ['LoggedOut', 401],
+    ['TempBanned', 402],
+    ['AccountLocked', 403],
+    ['UnknownLogout', 406],
+    ['ClientOutdated', 405],
+    ['BadUserAgent', 409],
+    ['CatExpired', 413],
+    ['CatInvalid', 414],
+    ['NotFound', 415],
+    ['ClientUnknown', 418],
+    ['InternalServerError', 500],
+    ['Experimental', 501],
+    ['ServiceUnavailable', 503]
+]);
+const completionFailureCode = (reason) => {
+    const named = COMPLETION_FAILURE_CODES.get(reason);
+    if (named !== undefined)
+        return named;
+    const unknown = /^Unknown\((-?\d+)\)$/.exec(reason)?.[1];
+    return unknown === undefined ? undefined : Number(unknown);
+};
 /** Build the ws EventEmitter with auto-enable raw node forwarding */
 const makeWASocket = (config) => {
     const fullConfig = { ...DEFAULT_CONNECTION_CONFIG, ...config };
@@ -192,24 +217,19 @@ const makeWASocket = (config) => {
                 throw firstFlushError;
         },
         release: async (client) => {
-            // `disconnect()` before `free()` is defence in depth, not a fix for a
-            // reproduced bug on this path.
-            //
-            // The hazard is real and reproducible at the bridge: freeing a client
-            // with any call still pending corrupts the wasm heap — dlmalloc trips
-            // `assertion failed: psize <= size + max_overhead` and the process
-            // dies on `RuntimeError: unreachable`, from a microtask no try/catch
-            // here can reach, since `free()` itself returns normally.
-            // `logout()`, `disconnect()` and a plain `fetchBlocklist()` all
-            // reproduce it — see `__tests__/bridge-free-safety.test.ts`.
+            // `disconnect()` before `free()` drains exactly one shape: a
+            // `disconnect()` still in flight. Since bridge 0.21.1, freeing
+            // with ordinary calls pending (`fetchBlocklist()`, `logout()`) is
+            // safe — its `Drop` signals shutdown and aborts the background
+            // tasks — but freeing mid-`disconnect()` still aborts the process
+            // (`async-lock` panicking while panicking). See
+            // `__tests__/bridge-free-safety.test.ts`.
             //
-            // What keeps teardown off that path is the `ws.close()` above, which
-            // is itself a `client.disconnect()` (`Compatibility/websocket-client.ts`).
-            // This is the belt to that braces, and the gap it closes is
-            // `WebSocketClient.close()`'s early return when `closing`/`closed` is
-            // already set: that path does NOT await the disconnect it skipped, so
-            // `void sock.ws.close(); await sock.end()` could otherwise reach
-            // `free()` with the first disconnect still running.
+            // That shape is reachable: `WebSocketClient.close()` early-returns
+            // when `closing`/`closed` is already set without awaiting the
+            // disconnect it skipped, so `void sock.ws.close(); await sock.end()`
+            // could otherwise reach `free()` with the first disconnect still
+            // running. Awaiting it here is the belt to `ws.close()`'s braces.
             let disconnected = true;
             try {
                 await client.disconnect();
@@ -261,6 +281,37 @@ const makeWASocket = (config) => {
     let autoReconnectEnabled = true;
     /** Owns reporting the terminal close: once, after teardown, never not at all. */
     const terminalClose = makeTerminalCloseReporter({ logger });
+    const runCompletionError = (completion) => {
+        let statusCode = DisconnectReason.connectionClosed;
+        let message = 'Connection closed';
+        if (completion.reason === 'unknown') {
+            message = `Connection run ended: ${completion.detail}`;
+        }
+        else if (completion.reason === 'stopped') {
+            message = 'Connection run stopped';
+        }
+        else if (completion.reason === 'already-running') {
+            message = 'Connection run was already running';
+        }
+        else if (completion.reason === 'auto-reconnect-disabled') {
+            const protocol = completion.protocolError;
+            if (protocol?.kind === 'conflict') {
+                statusCode = DisconnectReason.connectionReplaced;
+                message = 'Connection replaced';
+            }
+            else if (protocol?.kind === 'stream-error') {
+                statusCode = mapConnectFailureToDisconnect(protocol.code);
+            }
+            else if (protocol?.kind === 'connect-failure') {
+                statusCode = mapConnectFailureToDisconnect(completionFailureCode(protocol.reason));
+            }
+            else if (completion.connection?.kind === 'server-close') {
+                message = completion.connection.reason;
+            }
+        }
+        return new Boom(message, { statusCode, data: { runCompletion: completion } });
+    };
+    const reportTerminalClose = (error, publish) => terminalClose.reportAfter(() => owner.close(error).finally(() => initPromise), publish);
     /**
      * Held in a reporter rather than captured, because `sock.onUnexpectedError`
      * is an assignable property: a consumer that replaces it has to be the one
@@ -284,61 +335,42 @@ const makeWASocket = (config) => {
         setUser: u => {
             user = u;
         },
-        getClient: () => {
-            // `peek()` keeps returning the client through `closing` so teardown
-            // can still close the transport with it — but that is teardown's
-            // client, not everyone's. Handing it to an ordinary call racing
-            // shutdown, or made from an end handler, starts a bridge operation
-            // while the client is being disconnected and freed, which is the
-            // heap-corruption hazard the whole teardown ordering exists to
-            // avoid. Refuse from the moment `close()` is called.
-            if (owner.isClosing()) {
-                return Promise.reject(new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
-            }
-            // Otherwise gated on `initialized`, not merely on the client
-            // existing. `adopt()` publishes it several awaits before
-            // `setDeviceProps`, the account lookups and `run()`, so keying off
-            // `peek()` alone would hand ordinary calls like `sendMessage()` a
-            // half-built client whose read loop has not started — and skip the
-            // `initError` check when startup later fails.
-            if (initialized) {
-                const ready = owner.peek();
-                if (ready)
-                    return Promise.resolve(wrapBridgeClient(ready));
-            }
-            return initPromise.then(() => {
-                // Rechecked after the await: a close landing while startup was
-                // still running would otherwise be handed the client anyway.
-                //
-                // The window between handing a client back and the call reaching
-                // wasm cannot be closed here — that needs in-flight call
-                // tracking. What covers it is `release`, which awaits
-                // `client.disconnect()` before `free()`; the corruption comes
-                // from freeing with a call pending, and the disconnect drains
-                // those first (`__tests__/bridge-free-safety.test.ts`).
-                if (owner.isClosing()) {
-                    throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
-                }
-                if (initError) {
-                    throw new Boom('Bridge client failed to initialize: ' + initError.message, { statusCode: 500 });
-                }
-                const built = owner.peek();
-                if (!built)
-                    throw new Boom('Client not initialized', { statusCode: 500 });
-                return wrapBridgeClient(built);
-            });
-        },
-        getClientSync: () => {
-            // Same rule as `getClient` — see there.
+        withClient: makeWithClient(getClient)
+    };
+    function getClient() {
+        // Teardown retains the client through closing to disconnect the transport.
+        // Ordinary operations must stop being admitted when close() is called.
+        if (owner.isClosing()) {
+            return Promise.reject(new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed }));
+        }
+        // Otherwise gated on `initialized`, not merely on the client
+        // existing. `adopt()` publishes it several awaits before
+        // `setDeviceProps`, the account lookups and `run()`, so keying off
+        // `peek()` alone would hand ordinary calls like `sendMessage()` a
+        // half-built client whose read loop has not started — and skip the
+        // `initError` check when startup later fails.
+        if (initialized) {
+            const ready = owner.peek();
+            if (ready)
+                return Promise.resolve(wrapBridgeClient(ready));
+        }
+        return initPromise.then(() => {
+            // Closing may have started while initialization was pending.
+            // This gate does not track admitted operations. Bridge 0.21.1 tolerates
+            // free() during ordinary calls, but not during disconnect(); release
+            // still awaits that drain before freeing the client.
             if (owner.isClosing()) {
                 throw new Boom('Connection Closed', { statusCode: DisconnectReason.connectionClosed });
             }
+            if (initError) {
+                throw new Boom('Bridge client failed to initialize: ' + initError.message, { statusCode: 500 });
+            }
             const built = owner.peek();
             if (!built)
                 throw new Boom('Client not initialized', { statusCode: 500 });
             return wrapBridgeClient(built);
-        }
-    };
+        });
+    }
     // The native repository delegates Signal state directly to the core and does
     // not need the standalone transaction facade. Keep that facade lazy for the
     // public authState and custom repository contracts that can observe it.
@@ -401,7 +433,7 @@ const makeWASocket = (config) => {
             // is still owned. This waits for the real teardown, and cannot
             // deadlock because `reportAfter` runs it detached; nothing in the
             // teardown is waiting on this.
-            terminalClose.reportAfter(() => owner.close(error).finally(() => initPromise), publish);
+            reportTerminalClose(error, publish);
         },
         isAutoReconnectEnabled: () => autoReconnectEnabled,
         // Timers the dispatcher armed outlive the events that armed them, and
@@ -527,23 +559,46 @@ const makeWASocket = (config) => {
         // starting the read loop now would run against a handle about to go.
         if (owner.isClosing())
             return;
-        // `run()` spawns the connect/handshake/read/reconnect loop as a
-        // background task and returns `void` — it deliberately is not `async`,
-        // so that it does not hold a wasm-bindgen borrow on `self` that would
-        // block `disconnect()`.
-        //
-        // Consequence: the loop's exit is not observable from here. The engine
-        // clears `enable_auto_reconnect` and breaks out on every terminal
-        // disconnect (conflict/401/409/516, and any `<failure>` whose reason is
-        // not 500/503), and when it does, the `WasmWhatsAppClient` is dead
-        // weight that only `sock.end()` can free — nothing else can, because
-        // the bridge holds the JS event callbacks as wasm-bindgen externrefs,
-        // those close over `ctx`, and `ctx` closes over `client`, so the cycle
-        // crosses the JS/wasm boundary and no `FinalizationRegistry` fires.
-        // Freeing that automatically needs the bridge to expose loop completion
-        // (a terminal callback or an awaitable handle); until it does, the
-        // consumer has to call `sock.end()` on a terminal close.
+        // `run()` deliberately returns immediately so callers can use the
+        // client while supervision owns its background task. Registering the
+        // completion observer after it is started is safe: bridge 0.21.0 admits
+        // late observers against the stored result for this run generation.
         created.run();
+        const observedClient = created;
+        void created
+            .waitForRunCompletion()
+            .then(completion => {
+            // The owner identity is the socket generation fence. A completion
+            // from a client that teardown already released must never close a
+            // later socket using the same auth state.
+            if (owner.isClosing() || owner.peek() !== observedClient)
+                return;
+            const error = runCompletionError(completion);
+            reportTerminalClose(error, () => ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: { error, date: new Date() }
+            }));
+        }, error => {
+            if (owner.isClosing() || owner.peek() !== observedClient)
+                return;
+            const closeError = new Boom('Connection run ended without a completion result', {
+                statusCode: DisconnectReason.connectionClosed
+            });
+            reportTerminalClose(closeError, () => ev.emit('connection.update', {
+                connection: 'close',
+                lastDisconnect: { error: closeError, date: new Date() }
+            }));
+            try {
+                logger.error({ err: error }, 'bridge run completion observation failed');
+            }
+            catch {
+                // A consumer logger cannot prevent the terminal cleanup above.
+            }
+        })
+            .catch(() => {
+            // The reporter contains teardown and publish failures; this final guard
+            // also contains a consumer logger that throws from an observation path.
+        });
         initialized = true;
     };
     /**
@@ -698,7 +753,7 @@ const makeWASocket = (config) => {
         });
     };
     const fetchReachoutTimelock = async () => {
-        const payload = await (await ctx.getClient()).fetchReachoutTimelock();
+        const payload = await ctx.withClient(client => client.fetchReachoutTimelock());
         const state = mapReachoutTimelock(payload) ?? { isActive: false };
         ev.emit('connection.update', { reachoutTimeLock: state });
         return state;
@@ -706,14 +761,14 @@ const makeWASocket = (config) => {
     const query = async (node, timeoutMs) => {
         if (!node.attrs.id)
             node.attrs.id = generateMessageTag();
-        const result = (await (await ctx.getClient()).queryNode(node, timeoutMs));
+        const result = (await ctx.withClient(client => client.queryNode(node, timeoutMs)));
         assertNodeErrorFree(result);
         return result;
     };
     const waitForMessage = makeTaggedMessageWaiter(ws, logger, fullConfig.defaultQueryTimeoutMs);
     const usyncMethods = makeUSyncMethods({
         queryNode: query,
-        queryUsync: async (typedQuery) => (await ctx.getClient()).queryUsync(typedQuery)
+        queryUsync: async (typedQuery) => ctx.withClient(client => client.queryUsync(typedQuery))
     });
     const sock = {
         ev,
@@ -798,18 +853,18 @@ const makeWASocket = (config) => {
         notificationMutex,
         generateMessageTag,
         sendNode: async (frame) => {
-            return (await ctx.getClient()).sendNode(frame);
+            return ctx.withClient(client => client.sendNode(frame));
         },
         assertSessions: async (jids, force) => {
-            return (await ctx.getClient()).assertSessions(jids, force ?? false);
+            return ctx.withClient(client => client.assertSessions(jids, force ?? false));
         },
         getUSyncDevices: async (jids, useCache, ignoreZeroDevices) => {
-            return (await ctx.getClient()).getUSyncDevices(jids, useCache, ignoreZeroDevices);
+            return ctx.withClient(client => client.getUSyncDevices(jids, useCache, ignoreZeroDevices));
         },
         waitForMessage,
         query,
         sendRawMessage: async (data) => {
-            return (await ctx.getClient()).sendRawMessage(data instanceof Uint8Array ? data : new Uint8Array(data));
+            return ctx.withClient(client => client.sendRawMessage(data instanceof Uint8Array ? data : new Uint8Array(data)));
         },
         /**
          * `dsmMessage` is accepted so the signature matches upstream, and
@@ -823,7 +878,7 @@ const makeWASocket = (config) => {
                 throw new Boom('createParticipantNodes: dsmMessage is not supported, the engine encrypts one payload for every recipient and cannot substitute a different one for your own devices', { statusCode: 501 });
             }
             const bytes = encodeProtoCompat('Message', message);
-            return (await ctx.getClient()).createParticipantNodesBytes(jids, bytes, extraAttrs ?? {});
+            return ctx.withClient(client => client.createParticipantNodesBytes(jids, bytes, extraAttrs ?? {}));
         },
         signalRepository,
         ...makePreKeyMethods(ctx),
@@ -848,14 +903,15 @@ const makeWASocket = (config) => {
             // Ahead of the client: an off-union value used to fall through to the
             // chat-state branch and be reported as a missing jid.
             assertArgumentDomain('sendPresenceUpdate', 'type', type, WA_PRESENCES);
-            const c = await ctx.getClient();
-            if (type === 'available' || type === 'unavailable') {
-                return c.sendPresence(type);
-            }
-            if (!toJid) {
-                throw new Boom(`sendPresenceUpdate('${type}') requires a target jid`, { statusCode: 400 });
-            }
-            return c.sendChatState(toJid, type);
+            return ctx.withClient(async (c) => {
+                if (type === 'available' || type === 'unavailable') {
+                    return c.sendPresence(type);
+                }
+                if (!toJid) {
+                    throw new Boom(`sendPresenceUpdate('${type}') requires a target jid`, { statusCode: 400 });
+                }
+                return c.sendChatState(toJid, type);
+            });
         },
         /**
          * Plaintext media upload helper, source-compatible with the upstream
@@ -868,15 +924,15 @@ const makeWASocket = (config) => {
             // `toBridgeMediaType` below still refuses the ones it cannot map.
             assertArgumentDomain('waUploadToServer', 'mediaType', opts?.mediaType, MEDIA_TYPES);
             const bytes = data instanceof Uint8Array && !Buffer.isBuffer(data) ? data : new Uint8Array(data);
-            return (await ctx.getClient()).uploadMedia(bytes, toBridgeMediaType(opts.mediaType));
+            return ctx.withClient(client => client.uploadMedia(bytes, toBridgeMediaType(opts.mediaType)));
         },
         ...makePrivacyMethods(ctx),
         updateDefaultDisappearingMode: async (duration) => {
-            await (await ctx.getClient()).updateDefaultDisappearingMode(duration);
+            await ctx.withClient(client => client.updateDefaultDisappearingMode(duration));
         },
         rejectCall: async (callId, callFrom) => {
             const context = activeCallContexts.get(callId);
-            await (await ctx.getClient()).rejectCall(callId, context?.peer ?? callFrom, context?.callCreator ?? callFrom);
+            await ctx.withClient(client => client.rejectCall(callId, context?.peer ?? callFrom, context?.callCreator ?? callFrom));
             activeCallContexts.delete(callId);
         },
         /**
@@ -896,14 +952,14 @@ const makeWASocket = (config) => {
         /** Upstream Baileys-compatible name. */
         fetchAccountReachoutTimelock: fetchReachoutTimelock,
         getBusinessProfile: async (jid) => {
-            return bridgeBusinessProfileToBaileys(await (await ctx.getClient()).getBusinessProfile(jid));
+            return bridgeBusinessProfileToBaileys(await ctx.withClient(client => client.getBusinessProfile(jid)));
         },
         fetchMessageHistory: async (count, oldestMsgKey, oldestMsgTimestamp) => {
-            return (await ctx.getClient()).fetchMessageHistory(count, oldestMsgKey.remoteJid || '', oldestMsgKey.id || '', oldestMsgKey.fromMe || false, typeof oldestMsgTimestamp === 'number' ? oldestMsgTimestamp : oldestMsgTimestamp.toNumber());
+            return ctx.withClient(client => client.fetchMessageHistory(count, oldestMsgKey.remoteJid || '', oldestMsgKey.id || '', oldestMsgKey.fromMe || false, typeof oldestMsgTimestamp === 'number' ? oldestMsgTimestamp : oldestMsgTimestamp.toNumber()));
         },
         sendStatusMessage: async (message, recipients) => {
             const bytes = encodeProtoCompat('Message', message);
-            return (await ctx.getClient()).sendStatusMessageBytes(bytes, recipients);
+            return ctx.withClient(client => client.sendStatusMessageBytes(bytes, recipients));
         },
         ...makeMessageMethods(ctx),
         ...groupMethods,
@@ -924,11 +980,11 @@ const makeWASocket = (config) => {
             // the context below is built, and a check past that await reports a
             // stack without the caller in it.
             assertArgumentDomain('downloadMedia', 'type', type, MEDIA_DOWNLOAD_TYPES);
-            return downloadMediaMessage(message, type, options, {
+            return ctx.withClient(client => downloadMediaMessage(message, type, options, {
                 logger,
                 reuploadRequest: (m) => sock.updateMediaMessage(m),
-                waClient: await ctx.getClient()
-            });
+                waClient: client
+            }));
         }
     };
     // Assigning replaces the handler the socket itself reports through, rather

package/lib/Socket/internals.js

@@ -65,7 +65,7 @@ export const makeInternalMethods = (ctx) => {
          * that wants the next attempt waits again.
          */
         waitForSocketOpen: async () => {
-            await (await ctx.getClient()).waitForSocket(TRANSPORT_CONNECT_TIMEOUT_MS);
+            await ctx.withClient(client => client.waitForSocket(TRANSPORT_CONNECT_TIMEOUT_MS));
         },
         /**
          * Publishes a message onto the event bus, which is this layer's own job.