fixo-baileys 1.0.7 → 1.0.9

package/README.md

@@ -956,17 +956,127 @@ console.log(res.serverId)    // channel server id (undefined if the server didn'
 | `mentions` | Array of JIDs to mention |
 | `linkPreview` | `false` to disable the automatic link preview for text |
 | `messageId` *(options)* | Custom message ID |
+| `checkPermission` *(options)* | `true` = call `newsletterCanPostStatus()` first and throw `403` before uploading any media |
 
-Errors: a non-channel JID throws `400`; posting from an account that is not owner/admin throws `403`.
+Errors: a non-channel JID throws `400`; posting from an account that is not owner/admin throws `403` ("Not an admin"); hitting WhatsApp's limit throws `429` (`error.data.retryAfter` when the server gives it).
+
+> 🎨 A **text** status always carries a background colour — if you don't pass `backgroundColor`, `#FFC107` is used.
+
+### ⚠️ `mode: 'status'` (default) vs `mode: 'post'`
+
+| `options.mode` | What is sent | Where it shows up |
+|:---|:---|:---|
+| `'status'` *(default, **experimental**)* | the message wrapped in `proto.Message.newsletterAdminProfileStatusMessage` (field 126) and published to the channel JID | meant to be a real **Channel Status** (Updates tab, 24 h) |
+| `'post'` | plain channel message (the old behaviour) | channel chat only — a normal post |
+
+> The `'status'` wrapper is based on WhatsApp's own protobuf definition, but the exact stanza WhatsApp uses has **not been verified against a real capture yet**.
+> If it still lands as a normal post, capture the real stanza (below) and open an issue / send the log.
+> Add `rawLog: true` to the 3rd argument to log the final payload: `sock.sendChannelStatus(jid, 'Hi', { rawLog: true })`.
+
+```js
+await sock.sendChannelStatus(channelJid, { image: { url: './pic.jpg' }, caption: 'Hi' })                 // status (experimental)
+await sock.sendChannelStatus(channelJid, { image: { url: './pic.jpg' }, caption: 'Hi' }, { mode: 'post' }) // old plain post
+```
+
+### 🔍 Capturing the real Channel Status stanza
+
+```js
+import makeWASocket from 'fixo-baileys'
+import { attachCapture } from 'fixo-baileys/tools/capture-channel-status.js'
+
+const sock = makeWASocket({ /* ... */ })
+attachCapture(sock)            // writes every received stanza to ./capture.log
+```
+Then post a real Channel Status (one text, one photo) **from your phone** and send `capture.log`.
 
 **How it works (for contributors)**
 - `lib/Socket/messages-send.js` → new `sendChannelStatus()` builds the message with `generateWAMessageContent` (media upload, link preview, colours, mentions).
+- `lib/Socket/newsletter-channel.js` → all channel node builders / parsers / error mapping (see the [Channel API](#-channel-api-newsletter-methods) below).
 - `lib/Socket/newsletter.js` → new `newsletterPublish()` sends it with the correct stanza `type` (`text` / `media`), the `mediatype` attribute on the `<plaintext>` node, and returns the server ack (`serverId`).
 
 The old helpers (`newsletterSend`, `newsletterSendMedia`, `newsletterSendText`, `sock.sendMessage(channelJid, ...)`) work exactly as before.
 
 ---
 
+## 🛠️ Channel API (newsletter methods)
+
+All of these live in `lib/Socket/newsletter-channel.js` and are available directly on `sock`. Channel JIDs look like `120363xxxxxxxxxxxx@newsletter`.
+Metadata / create / update use `xmlns="w:mex"`; react / remove / history use `xmlns="newsletter"`.
+
+| Method | What it does |
+|:---|:---|
+| `sock.sendChannelStatus(jid, content, options?)` | Post text / image / video / audio / document / sticker to a channel (see above) |
+| `sock.newsletterCanPostStatus(jid)` | `{ canPost, role }` — `true` only for `OWNER` / `ADMIN` |
+| `sock.newsletterCreate(name, description?)` | Create a channel → metadata incl. `jid` |
+| `sock.newsletterUpdate(jid, { name, description, pictureBuffer })` | Change name / description / picture (`pictureBuffer: null` removes the picture) |
+| `sock.newsletterReactMessage(jid, serverId, reactionCode)` | React to a channel message (`''` removes your reaction) |
+| `sock.newsletterRemoveMessage(jid, serverId)` | Delete (revoke) a message you posted |
+| `sock.newsletterMetadata(type, key)` | Full channel info by `'invite'` code (or full link) or `'jid'` |
+| `sock.newsletterFetchMessages(jid, count, since?, after?)` | Channel history as an array |
+
+```js
+const jid = '120363123456789012@newsletter'
+
+// ✅ 1) Can I post here?
+const { canPost, role } = await sock.newsletterCanPostStatus(jid)
+if (!canPost) return console.log('Not an admin, role =', role)
+
+// 🆕 2) Create a channel
+const ch = await sock.newsletterCreate('FIXO Updates', 'News from the bot')
+console.log(ch.jid, ch.invite)
+
+// ✏️ 3) Update name / description / picture (all optional, pass only what you change)
+await sock.newsletterUpdate(ch.jid, {
+  name: 'FIXO Updates 🚀',
+  description: 'Official updates',
+  pictureBuffer: fs.readFileSync('./logo.jpg')   // Buffer | { url } | stream ; null = remove
+})
+
+// 🔎 4) Metadata (by invite code, link or JID)
+const meta = await sock.newsletterMetadata('invite', '0029Vb8c75l1SWstC9vY7c37')
+// const meta = await sock.newsletterMetadata('jid', jid)
+console.log(meta.jid, meta.name, meta.subscribers, meta.verified, meta.role, meta.admins.count)
+// raw fields (meta.thread_metadata, meta.viewer_metadata) are still there
+
+// 📜 5) History -> [{ serverId, id, message, timestamp, views, reactions }]
+const msgs = await sock.newsletterFetchMessages(jid, 10)
+for (const m of msgs) console.log(m.serverId, m.timestamp, m.message?.conversation, m.reactions)
+// `await sock.newsletterFetchMessages(jid, 10, undefined, undefined, { raw: true })` returns the raw node
+
+// 💖 6) React / un-react
+await sock.newsletterReactMessage(jid, msgs[0].serverId, '🔥')
+await sock.newsletterReactMessage(jid, msgs[0].serverId, '')   // remove
+
+// 🗑️ 7) Remove a message
+await sock.newsletterRemoveMessage(jid, msgs[0].serverId)
+
+// 📣 8) Post a status safely
+await sock.sendChannelStatus(jid, { text: 'Hello', backgroundColor: '#FFC107', font: 2 }, { checkPermission: true })
+```
+
+**Error handling** — every method above maps server errors to a `Boom`:
+
+| `error.output.statusCode` | Meaning |
+|:---|:---|
+| `400` | Bad argument (not a `@newsletter` JID, missing `serverId`, wrong `type`, nothing to update) |
+| `403` | **Not an admin** — account is not the channel owner/admin |
+| `404` | Channel / message not found |
+| `429` | **Rate limit** — retry later (`error.data.retryAfter` if the server sent it) |
+
+```js
+try {
+  await sock.sendChannelStatus(jid, 'Hi')
+} catch (e) {
+  if (e.output?.statusCode === 429) await new Promise(r => setTimeout(r, (e.data?.retryAfter ?? 30) * 1000))
+  else if (e.output?.statusCode === 403) console.log('Not an admin')
+  else throw e
+}
+```
+
+> `serverId` is the channel's own message id (`res.serverId` from `sendChannelStatus`, or `m.serverId` from `newsletterFetchMessages`) — **not** the normal `key.id`.
+
+---
+
 ## 📊 Polls (`sendPoll` / `sendPollVote`)
 
 Create polls and vote on them — in chats, groups and **channels**.

package/WAProto/WAProto.proto

@@ -2150,6 +2150,7 @@ message Message {
     optional FutureProofMessage questionMessage = 101;
     optional MessageHistoryNotice messageHistoryNotice = 102;
     optional FutureProofMessage groupStatusMessageV2 = 103;
+    optional FutureProofMessage newsletterAdminProfileStatusMessage = 126;
     optional FutureProofMessage botForwardedMessage = 104;
     optional StatusQuestionAnswerMessage statusQuestionAnswerMessage = 105;
     optional FutureProofMessage questionReplyMessage = 106;

package/WAProto/index.d.ts

@@ -5269,6 +5269,7 @@ export namespace proto {
         questionMessage?: (proto.Message.IFutureProofMessage|null);
         messageHistoryNotice?: (proto.Message.IMessageHistoryNotice|null);
         groupStatusMessageV2?: (proto.Message.IFutureProofMessage|null);
+        newsletterAdminProfileStatusMessage?: (proto.Message.IFutureProofMessage|null);
         botForwardedMessage?: (proto.Message.IFutureProofMessage|null);
         statusQuestionAnswerMessage?: (proto.Message.IStatusQuestionAnswerMessage|null);
         questionReplyMessage?: (proto.Message.IFutureProofMessage|null);
@@ -5368,6 +5369,7 @@ export namespace proto {
         public questionMessage?: (proto.Message.IFutureProofMessage|null);
         public messageHistoryNotice?: (proto.Message.IMessageHistoryNotice|null);
         public groupStatusMessageV2?: (proto.Message.IFutureProofMessage|null);
+        public newsletterAdminProfileStatusMessage?: (proto.Message.IFutureProofMessage|null);
         public botForwardedMessage?: (proto.Message.IFutureProofMessage|null);
         public statusQuestionAnswerMessage?: (proto.Message.IStatusQuestionAnswerMessage|null);
         public questionReplyMessage?: (proto.Message.IFutureProofMessage|null);

package/WAProto/index.js

@@ -35552,6 +35552,7 @@ export const proto = $root.proto = (() => {
         Message.prototype.questionMessage = null;
         Message.prototype.messageHistoryNotice = null;
         Message.prototype.groupStatusMessageV2 = null;
+        Message.prototype.newsletterAdminProfileStatusMessage = null;
         Message.prototype.botForwardedMessage = null;
         Message.prototype.statusQuestionAnswerMessage = null;
         Message.prototype.questionReplyMessage = null;
@@ -36080,6 +36081,12 @@ export const proto = $root.proto = (() => {
             set: $util.oneOfSetter($oneOfFields)
         });
 
+        // Virtual OneOf for proto3 optional field
+        Object.defineProperty(Message.prototype, "_newsletterAdminProfileStatusMessage", {
+            get: $util.oneOfGetter($oneOfFields = ["newsletterAdminProfileStatusMessage"]),
+            set: $util.oneOfSetter($oneOfFields)
+        });
+
         // Virtual OneOf for proto3 optional field
         Object.defineProperty(Message.prototype, "_botForwardedMessage", {
             get: $util.oneOfGetter($oneOfFields = ["botForwardedMessage"]),
@@ -36313,6 +36320,8 @@ export const proto = $root.proto = (() => {
                 $root.proto.Message.MessageHistoryNotice.encode(m.messageHistoryNotice, w.uint32(818).fork()).ldelim();
             if (m.groupStatusMessageV2 != null && Object.hasOwnProperty.call(m, "groupStatusMessageV2"))
                 $root.proto.Message.FutureProofMessage.encode(m.groupStatusMessageV2, w.uint32(826).fork()).ldelim();
+            if (m.newsletterAdminProfileStatusMessage != null && Object.hasOwnProperty.call(m, "newsletterAdminProfileStatusMessage"))
+                $root.proto.Message.FutureProofMessage.encode(m.newsletterAdminProfileStatusMessage, w.uint32(1010).fork()).ldelim();
             if (m.botForwardedMessage != null && Object.hasOwnProperty.call(m, "botForwardedMessage"))
                 $root.proto.Message.FutureProofMessage.encode(m.botForwardedMessage, w.uint32(834).fork()).ldelim();
             if (m.statusQuestionAnswerMessage != null && Object.hasOwnProperty.call(m, "statusQuestionAnswerMessage"))
@@ -36687,6 +36696,10 @@ export const proto = $root.proto = (() => {
                         m.groupStatusMessageV2 = $root.proto.Message.FutureProofMessage.decode(r, r.uint32());
                         break;
                     }
+                case 126: {
+                        m.newsletterAdminProfileStatusMessage = $root.proto.Message.FutureProofMessage.decode(r, r.uint32());
+                        break;
+                    }
                 case 104: {
                         m.botForwardedMessage = $root.proto.Message.FutureProofMessage.decode(r, r.uint32());
                         break;
@@ -37163,6 +37176,11 @@ export const proto = $root.proto = (() => {
                     throw TypeError(".proto.Message.groupStatusMessageV2: object expected");
                 m.groupStatusMessageV2 = $root.proto.Message.FutureProofMessage.fromObject(d.groupStatusMessageV2);
             }
+            if (d.newsletterAdminProfileStatusMessage != null) {
+                if (typeof d.newsletterAdminProfileStatusMessage !== "object")
+                    throw TypeError(".proto.Message.newsletterAdminProfileStatusMessage: object expected");
+                m.newsletterAdminProfileStatusMessage = $root.proto.Message.FutureProofMessage.fromObject(d.newsletterAdminProfileStatusMessage);
+            }
             if (d.botForwardedMessage != null) {
                 if (typeof d.botForwardedMessage !== "object")
                     throw TypeError(".proto.Message.botForwardedMessage: object expected");
@@ -37645,6 +37663,11 @@ export const proto = $root.proto = (() => {
                 if (o.oneofs)
                     d._groupStatusMessageV2 = "groupStatusMessageV2";
             }
+            if (m.newsletterAdminProfileStatusMessage != null && m.hasOwnProperty("newsletterAdminProfileStatusMessage")) {
+                d.newsletterAdminProfileStatusMessage = $root.proto.Message.FutureProofMessage.toObject(m.newsletterAdminProfileStatusMessage, o);
+                if (o.oneofs)
+                    d._newsletterAdminProfileStatusMessage = "newsletterAdminProfileStatusMessage";
+            }
             if (m.botForwardedMessage != null && m.hasOwnProperty("botForwardedMessage")) {
                 d.botForwardedMessage = $root.proto.Message.FutureProofMessage.toObject(m.botForwardedMessage, o);
                 if (o.oneofs)

package/lib/Socket/messages-send.js

@@ -60,6 +60,7 @@ import {
 } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
+import { DEFAULT_STATUS_BACKGROUND, mapNewsletterError } from './newsletter-channel.js';
 
 export const makeMessagesSocket = (config) => {
     const {
@@ -1267,6 +1268,14 @@ export const makeMessagesSocket = (config) => {
         // ── Channel Status (post to a WhatsApp Channel like a user posts a status) ──
         // sock.sendChannelStatus(channelJid, 'text' | { text, backgroundColor, font, textColor }
         //                                   | { image|video|audio|document|sticker, caption, ... }, options)
+        //
+        // options.mode:
+        //   'status' (default, EXPERIMENTAL) -> the message is wrapped in
+        //            proto.Message.newsletterAdminProfileStatusMessage (field 126), which is the
+        //            wrapper WhatsApp uses for a channel admin's *status* (Updates tab, 24h).
+        //            The exact wire format is not verified against a real capture yet.
+        //   'post'   -> old behaviour: plain channel post (shows up inside the channel chat only).
+        // options.rawLog = true -> logs the final proto + stanza attrs (logger.info) for debugging.
         sendChannelStatus: async (jid, content, options = {}) => {
             if (!isJidNewsletter(jid)) {
                 throw new Boom('sendChannelStatus needs a channel JID (xxxx@newsletter)', { statusCode: 400 });
@@ -1283,6 +1292,21 @@ export const makeMessagesSocket = (config) => {
                 font: font ?? options.font,
                 textColor: textColor ?? options.textColor
             };
+            const isTextOnly =
+                typeof body.text === 'string' &&
+                !(body.image || body.video || body.audio || body.document || body.sticker);
+            // a text status must have a background colour, otherwise it is shown like a plain chat message
+            if (isTextOnly && !style.backgroundColor) style.backgroundColor = DEFAULT_STATUS_BACKGROUND;
+
+            // optional: make sure the account is owner/admin before spending a media upload
+            if (options.checkPermission) {
+                const { canPost } = await sock.newsletterCanPostStatus(jid);
+                if (!canPost) {
+                    throw new Boom('Not an admin: the connected account cannot post to this channel', {
+                        statusCode: 403
+                    });
+                }
+            }
 
             const generated = await generateWAMessageContent(body, {
                 logger,
@@ -1318,22 +1342,28 @@ export const makeMessagesSocket = (config) => {
             else if (inner.documentMessage) [type, mediatype] = ['media', 'document'];
             else if (inner.stickerMessage) [type, mediatype] = ['media', 'sticker'];
 
+            const mode = options.mode === 'post' ? 'post' : 'status';
+            const toSend =
+                mode === 'status'
+                    ? proto.Message.create({
+                          newsletterAdminProfileStatusMessage: proto.Message.FutureProofMessage.create({ message })
+                      })
+                    : message;
+
+            if (options.rawLog) {
+                logger.info({ jid, mode, type, mediatype, proto: toSend.toJSON?.() }, 'sendChannelStatus payload');
+            }
+
             try {
-                return await sock.newsletterPublish(jid, message, {
+                return await sock.newsletterPublish(jid, toSend, {
                     messageId: options.messageId,
                     additionalAttributes: options.additionalAttributes,
                     type,
                     mediatype
                 });
             } catch (error) {
-                const code = error?.output?.statusCode ?? error?.data ?? error?.statusCode;
-                if (code === 401 || code === 403) {
-                    throw new Boom(
-                        'Not allowed to post in this channel — the connected account must be the channel owner/admin',
-                        { statusCode: 403, data: error }
-                    );
-                }
-                throw error;
+                // 403 -> not an admin, 429 -> rate limit (retryAfter in error.data), else untouched
+                throw mapNewsletterError(error, 'post a channel status');
             }
         },
 

package/lib/Socket/newsletter-channel.js

@@ -0,0 +1,366 @@
+// Channel (Newsletter) API layer.
+//
+// All node construction + response parsing for the channel helpers lives in this file.
+// It is mixed into the socket from `newsletter.js`, so every function below is exposed on `sock`:
+//
+//   sock.newsletterCanPostStatus(jid)
+//   sock.newsletterCreate(name, description)
+//   sock.newsletterUpdate(jid, { name, description, pictureBuffer })
+//   sock.newsletterReactMessage(jid, serverId, reaction)
+//   sock.newsletterRemoveMessage(jid, serverId)
+//   sock.newsletterMetadata(type, key)
+//   sock.newsletterFetchMessages(jid, count, since, after)
+//   (+ sock.sendChannelStatus in messages-send.js, which uses `mapNewsletterError` & `newsletterPublish`)
+//
+// Namespaces: metadata / create / update / admin-count go through `xmlns="w:mex"` (GraphQL over IQ,
+// see mex.js); message level actions (react / remove / history) use `xmlns="newsletter"` + <message> stanzas.
+import { Boom } from '@hapi/boom';
+import { proto } from '../../WAProto/index.js';
+import { QueryIds, XWAPaths } from '../Types/index.js';
+import { generateProfilePicture } from '../Utils/messages-media.js';
+import { getBinaryNodeChild, getBinaryNodeChildren, isJidNewsletter } from '../WABinary/index.js';
+
+export const NEWSLETTER_ADMIN_ROLES = ['OWNER', 'ADMIN'];
+// WhatsApp rejects text statuses without a background colour, so we always send one.
+export const DEFAULT_STATUS_BACKGROUND = '#FFC107';
+
+// ─────────────────────────── errors ───────────────────────────
+
+const extractCode = (err) => {
+    const candidates = [
+        err?.output?.statusCode,
+        err?.data?.attrs?.code,
+        err?.data?.extensions?.error_code,
+        err?.data?.content?.[0]?.attrs?.code,
+        err?.statusCode,
+        typeof err?.data === 'number' ? err.data : undefined
+    ];
+    for (const c of candidates) {
+        const n = parseInt(c, 10);
+        if (!Number.isNaN(n)) return n;
+    }
+    return undefined;
+};
+
+const extractText = (err) => {
+    const node = err?.data?.content?.[0]?.attrs?.text || err?.data?.attrs?.text;
+    return `${err?.message || ''} ${node || ''} ${err?.data?.message || ''}`.toLowerCase();
+};
+
+/**
+ * Normalises server / GraphQL errors into a Boom with a stable statusCode:
+ *  403 -> not an admin/owner · 429 -> rate limited (data.retryAfter if known) · 404 -> channel not found
+ * The original error is kept in `error.data.original`.
+ */
+export const mapNewsletterError = (err, action = 'newsletter request') => {
+    if (!err) return err;
+    const code = extractCode(err);
+    const text = extractText(err);
+
+    if (code === 429 || /rate[-_ ]?(limit|overlimit)|too many|overlimit/.test(text)) {
+        const retryAfter = parseInt(err?.data?.attrs?.retry_after ?? err?.data?.extensions?.retry_after, 10);
+        return new Boom(`Rate limit hit while trying to ${action} — slow down and retry later`, {
+            statusCode: 429,
+            data: { original: err, retryAfter: Number.isNaN(retryAfter) ? undefined : retryAfter }
+        });
+    }
+    if (
+        code === 401 ||
+        code === 403 ||
+        /not[-_ ]?authori[sz]ed|forbidden|not an admin|permission|admin_required|role/.test(text)
+    ) {
+        return new Boom(`Not an admin: the connected account is not allowed to ${action} on this channel`, {
+            statusCode: 403,
+            data: { original: err }
+        });
+    }
+    if (code === 404 || /not[-_ ]?found|item-not-found/.test(text)) {
+        return new Boom(`Channel or message not found while trying to ${action}`, {
+            statusCode: 404,
+            data: { original: err }
+        });
+    }
+    return err;
+};
+
+const guarded = async (action, fn) => {
+    try {
+        return await fn();
+    } catch (err) {
+        throw mapNewsletterError(err, action);
+    }
+};
+
+const assertChannelJid = (jid, fn) => {
+    if (!isJidNewsletter(jid)) {
+        throw new Boom(`${fn}: expected a channel JID (xxxx@newsletter), got "${jid}"`, { statusCode: 400 });
+    }
+};
+
+const assertServerId = (serverId, fn) => {
+    if (serverId === undefined || serverId === null || String(serverId).trim() === '') {
+        throw new Boom(`${fn}: serverId is required (the channel server id of the message)`, { statusCode: 400 });
+    }
+    return String(serverId);
+};
+
+// ─────────────────────────── parsers ───────────────────────────
+
+const text = (v) => (v && typeof v === 'object' ? v.text ?? null : v ?? null);
+
+const toInt = (v) => {
+    const n = parseInt(v, 10);
+    return Number.isNaN(n) ? undefined : n;
+};
+
+/** Accepts the raw mex payload ({ id, ... } or { result: { id, ... } }) */
+export const unwrapNewsletterResult = (result) => {
+    if (typeof result !== 'object' || result === null) return null;
+    if (typeof result.id === 'string') return result;
+    if (result.result && typeof result.result === 'object' && 'id' in result.result) return result.result;
+    return null;
+};
+
+/**
+ * Flat, friendly view of a channel. All raw mex fields (`thread_metadata`, `viewer_metadata`, ...) are kept,
+ * so older code that reads them keeps working.
+ */
+export const normalizeNewsletterMetadata = (raw, extra = {}) => {
+    const r = unwrapNewsletterResult(raw);
+    if (!r) return null;
+    const thread = r.thread_metadata || {};
+    const viewer = r.viewer_metadata || {};
+    const verification = thread.verification ?? null;
+    return {
+        ...r,
+        jid: r.id,
+        name: text(thread.name),
+        description: text(thread.description),
+        invite: thread.invite ?? null,
+        subscribers: toInt(thread.subscribers_count) ?? 0,
+        verification,
+        verified: verification === 'VERIFIED',
+        creationTime: toInt(thread.creation_time),
+        picture: thread.picture ? { id: thread.picture.id, directPath: thread.picture.direct_path } : null,
+        state: r.state?.type ?? r.state ?? null,
+        muted: viewer.mute === 'ON',
+        role: viewer.role ?? null,
+        isAdmin: NEWSLETTER_ADMIN_ROLES.includes(viewer.role),
+        isOwner: viewer.role === 'OWNER',
+        admins: {
+            count: extra.adminCount ?? null,
+            viewerRole: viewer.role ?? null
+        }
+    };
+};
+
+const findNodes = (node, tag, out = []) => {
+    if (!node || !Array.isArray(node.content)) return out;
+    for (const child of node.content) {
+        if (child?.tag === tag) out.push(child);
+        findNodes(child, tag, out);
+    }
+    return out;
+};
+
+const decodePlaintext = (node) => {
+    const plain = getBinaryNodeChild(node, 'plaintext');
+    if (!plain?.content) return null;
+    try {
+        const buf = typeof plain.content === 'string' ? Buffer.from(plain.content, 'binary') : Buffer.from(plain.content);
+        return proto.Message.decode(buf);
+    } catch {
+        return null;
+    }
+};
+
+/** <message_updates><messages><message server_id t>…</message></messages></message_updates> -> array */
+export const parseNewsletterMessages = (result) => {
+    return findNodes(result, 'message').map((node) => {
+        const reactions = getBinaryNodeChildren(getBinaryNodeChild(node, 'reactions'), 'reaction').map((r) => ({
+            code: r.attrs.code,
+            count: toInt(r.attrs.count) ?? 0
+        }));
+        const views = getBinaryNodeChild(node, 'views_count')?.attrs?.count;
+        return {
+            serverId: node.attrs.server_id,
+            id: node.attrs.message_id || node.attrs.id,
+            timestamp: toInt(node.attrs.t),
+            type: node.attrs.type,
+            message: decodePlaintext(node),
+            views: toInt(views),
+            reactions
+        };
+    });
+};
+
+// ─────────────────────────── factory ───────────────────────────
+
+export const makeNewsletterChannelApi = ({ query, generateMessageTag, executeWMexQuery }) => {
+    const newsletterMetadata = async (type, key, options = {}) => {
+        const t = String(type || '').toLowerCase();
+        if (t !== 'invite' && t !== 'jid') {
+            throw new Boom("newsletterMetadata: type must be 'invite' or 'jid'", { statusCode: 400 });
+        }
+        if (!key) throw new Boom('newsletterMetadata: key is required', { statusCode: 400 });
+        // accept a full invite link too
+        const cleanKey = t === 'invite' ? String(key).replace(/^.*\/channel\//, '').split(/[?#]/)[0] : key;
+
+        const raw = await guarded('fetch metadata', () =>
+            executeWMexQuery(
+                {
+                    fetch_creation_time: true,
+                    fetch_full_image: true,
+                    fetch_viewer_metadata: true,
+                    input: { key: cleanKey, type: t.toUpperCase() }
+                },
+                QueryIds.METADATA,
+                XWAPaths.xwa2_newsletter_metadata
+            )
+        );
+        const base = unwrapNewsletterResult(raw);
+        if (!base) return null;
+
+        let adminCount;
+        const isAdmin = NEWSLETTER_ADMIN_ROLES.includes(base.viewer_metadata?.role);
+        if (options.withAdmins !== false && isAdmin) {
+            try {
+                const res = await executeWMexQuery(
+                    { newsletter_id: base.id },
+                    QueryIds.ADMIN_COUNT,
+                    XWAPaths.xwa2_newsletter_admin_count
+                );
+                adminCount = toInt(res?.admin_count);
+            } catch {
+                adminCount = undefined; // admin count is best-effort
+            }
+        }
+        return normalizeNewsletterMetadata(base, { adminCount });
+    };
+
+    const newsletterCanPostStatus = async (jid) => {
+        assertChannelJid(jid, 'newsletterCanPostStatus');
+        try {
+            const meta = await newsletterMetadata('jid', jid, { withAdmins: false });
+            const role = meta?.role ?? null;
+            return { canPost: NEWSLETTER_ADMIN_ROLES.includes(role), role };
+        } catch (err) {
+            // "not an admin" / not found style failures simply mean the bot cannot post
+            if (err?.output?.statusCode === 403 || err?.output?.statusCode === 404) {
+                return { canPost: false, role: null };
+            }
+            throw err;
+        }
+    };
+
+    const newsletterCreate = async (name, description) => {
+        if (typeof name !== 'string' || !name.trim()) {
+            throw new Boom('newsletterCreate: name is required', { statusCode: 400 });
+        }
+        const raw = await guarded('create a channel', () =>
+            executeWMexQuery(
+                { input: { name: name.trim(), description: description ?? null } },
+                QueryIds.CREATE,
+                XWAPaths.xwa2_newsletter_create
+            )
+        );
+        const meta = normalizeNewsletterMetadata(raw);
+        if (!meta) {
+            throw new Boom('newsletterCreate: unexpected response from server', { statusCode: 500, data: raw });
+        }
+        // `jid` + legacy fields (`creation_time`, `mute_state`) so older callers keep working
+        return { ...meta, creation_time: meta.creationTime, mute_state: raw.viewer_metadata?.mute };
+    };
+
+    /**
+     * updates: { name?, description?, pictureBuffer? }
+     *  - pictureBuffer: Buffer | { url } | stream  (resized to a channel DP and uploaded as base64)
+     *  - pictureBuffer: null | '' removes the picture
+     */
+    const newsletterUpdate = async (jid, updates = {}) => {
+        assertChannelJid(jid, 'newsletterUpdate');
+        const { name, description, pictureBuffer, picture, ...rest } = updates;
+        const payload = { ...rest };
+        if (name !== undefined) payload.name = name;
+        if (description !== undefined) payload.description = description;
+
+        if (pictureBuffer === null || pictureBuffer === '') {
+            payload.picture = '';
+        } else if (pictureBuffer !== undefined) {
+            const { img } = await generateProfilePicture(pictureBuffer);
+            payload.picture = img.toString('base64');
+        } else if (picture !== undefined) {
+            payload.picture = picture; // already base64 (backward compatibility)
+        }
+        if (!Object.keys(payload).length) {
+            throw new Boom('newsletterUpdate: nothing to update (pass name, description or pictureBuffer)', {
+                statusCode: 400
+            });
+        }
+        return guarded('update the channel', () =>
+            executeWMexQuery(
+                { newsletter_id: jid, updates: { ...payload, settings: null } },
+                QueryIds.UPDATE_METADATA,
+                'xwa2_newsletter_update'
+            )
+        );
+    };
+
+    /** reactionCode = emoji to react, '' (or null) removes your reaction */
+    const newsletterReactMessage = async (jid, serverId, reactionCode) => {
+        assertChannelJid(jid, 'newsletterReactMessage');
+        const sid = assertServerId(serverId, 'newsletterReactMessage');
+        const code = reactionCode || '';
+        const id = generateMessageTag();
+        await guarded('react to a message', () =>
+            query({
+                tag: 'message',
+                attrs: { to: jid, id, type: 'reaction', server_id: sid, ...(code ? {} : { edit: '7' }) },
+                content: [{ tag: 'reaction', attrs: code ? { code } : {} }]
+            })
+        );
+        return { id, serverId: sid, reaction: code, removed: !code };
+    };
+
+    /** Revoke a message that was posted in the channel */
+    const newsletterRemoveMessage = async (jid, serverId) => {
+        assertChannelJid(jid, 'newsletterRemoveMessage');
+        const sid = assertServerId(serverId, 'newsletterRemoveMessage');
+        const id = generateMessageTag();
+        const ack = await guarded('remove a message', () =>
+            query({
+                tag: 'message',
+                attrs: { to: jid, id, type: 'text', edit: '8', server_id: sid },
+                content: []
+            })
+        );
+        return { id, serverId: sid, removed: true, ack };
+    };
+
+    /** Channel history -> [{ serverId, id, message, timestamp, views, reactions }] (`{ raw: true }` returns the node) */
+    const newsletterFetchMessages = async (jid, count = 20, since, after, options = {}) => {
+        assertChannelJid(jid, 'newsletterFetchMessages');
+        const attrs = { count: String(Math.max(1, parseInt(count, 10) || 20)) };
+        if (typeof since === 'number') attrs.since = String(since);
+        if (after) attrs.after = String(after);
+
+        const result = await guarded('fetch messages', () =>
+            query({
+                tag: 'iq',
+                attrs: { id: generateMessageTag(), type: 'get', xmlns: 'newsletter', to: jid },
+                content: [{ tag: 'message_updates', attrs }]
+            })
+        );
+        return options.raw ? result : parseNewsletterMessages(result);
+    };
+
+    return {
+        newsletterMetadata,
+        newsletterCanPostStatus,
+        newsletterCreate,
+        newsletterUpdate,
+        newsletterReactMessage,
+        newsletterRemoveMessage,
+        newsletterFetchMessages
+    };
+};

package/lib/Socket/newsletter.js

@@ -3,41 +3,9 @@ import { generateProfilePicture } from '../Utils/messages-media.js';
 import { getBinaryNodeChild } from '../WABinary/index.js';
 import { makeGroupsSocket } from './groups.js';
 import { executeWMexQuery as genericExecuteWMexQuery } from './mex.js';
+import { makeNewsletterChannelApi, mapNewsletterError } from './newsletter-channel.js';
 import { createHash } from 'crypto';
 
-const parseNewsletterCreateResponse = (response) => {
-    const { id, thread_metadata: thread, viewer_metadata: viewer } = response;
-    return {
-        id,
-        owner: undefined,
-        name: thread.name.text,
-        creation_time: parseInt(thread.creation_time, 10),
-        description: thread.description.text,
-        invite: thread.invite,
-        subscribers: parseInt(thread.subscribers_count, 10),
-        verification: thread.verification,
-        picture: {
-            id: thread.picture.id,
-            directPath: thread.picture.direct_path
-        },
-        mute_state: viewer.mute
-    };
-};
-
-const parseNewsletterMetadata = (result) => {
-    if (typeof result !== 'object' || result === null) return null;
-    if ('id' in result && typeof result.id === 'string') return result;
-    if (
-        'result' in result &&
-        typeof result.result === 'object' &&
-        result.result !== null &&
-        'id' in result.result
-    ) {
-        return result.result;
-    }
-    return null;
-};
-
 export const makeNewsletterSocket = (config) => {
     const sock = makeGroupsSocket(config);
     const { query, generateMessageTag } = sock;
@@ -46,13 +14,9 @@ export const makeNewsletterSocket = (config) => {
         return genericExecuteWMexQuery(variables, queryId, dataPath, query, generateMessageTag);
     };
 
-    const newsletterUpdate = async (jid, updates) => {
-        const variables = {
-            newsletter_id: jid,
-            updates: { ...updates, settings: null }
-        };
-        return executeWMexQuery(variables, QueryIds.UPDATE_METADATA, 'xwa2_newsletter_update');
-    };
+    // Channel API (create / update / metadata / react / remove / fetch / canPost) lives in newsletter-channel.js
+    const channelApi = makeNewsletterChannelApi({ query, generateMessageTag, executeWMexQuery });
+    const { newsletterUpdate } = channelApi;
 
     const _sendNewsletterNode = async (jid, encodedBytes, msgId, extraAttrs = {}, meta = {}) => {
         // meta.type      -> stanza type ('text' | 'media' | ...), defaults to 'text' (old behaviour)
@@ -183,20 +147,6 @@ export const makeNewsletterSocket = (config) => {
         newsletterSendDirect,
         newsletterPublish,
 
-        newsletterCreate: async (name, description) => {
-            const variables = {
-                input: { name, description: description ?? null }
-            };
-            const rawResponse = await executeWMexQuery(
-                variables,
-                QueryIds.CREATE,
-                XWAPaths.xwa2_newsletter_create
-            );
-            return parseNewsletterCreateResponse(rawResponse);
-        },
-
-        newsletterUpdate,
-
         newsletterSubscribers: async (jid) => {
             return executeWMexQuery(
                 { newsletter_id: jid },
@@ -205,21 +155,6 @@ export const makeNewsletterSocket = (config) => {
             );
         },
 
-        newsletterMetadata: async (type, key) => {
-            const variables = {
-                fetch_creation_time: true,
-                fetch_full_image: true,
-                fetch_viewer_metadata: true,
-                input: { key, type: type.toUpperCase() }
-            };
-            const result = await executeWMexQuery(
-                variables,
-                QueryIds.METADATA,
-                XWAPaths.xwa2_newsletter_metadata
-            );
-            return parseNewsletterMetadata(result);
-        },
-
         newsletterFollow: (jid) => {
             return executeWMexQuery(
                 { newsletter_id: jid },
@@ -269,42 +204,6 @@ export const makeNewsletterSocket = (config) => {
             return newsletterUpdate(jid, { picture: '' });
         },
 
-        newsletterReactMessage: async (jid, serverId, reaction) => {
-            await query({
-                tag: 'message',
-                attrs: {
-                    to: jid,
-                    ...(reaction ? {} : { edit: '7' }),
-                    type: 'reaction',
-                    server_id: serverId,
-                    id: generateMessageTag()
-                },
-                content: [
-                    {
-                        tag: 'reaction',
-                        attrs: reaction ? { code: reaction } : {}
-                    }
-                ]
-            });
-        },
-
-        newsletterFetchMessages: async (jid, count, since, after) => {
-            const messageUpdateAttrs = { count: count.toString() };
-            if (typeof since === 'number') messageUpdateAttrs.since = since.toString();
-            if (after) messageUpdateAttrs.after = after.toString();
-
-            return query({
-                tag: 'iq',
-                attrs: {
-                    id: generateMessageTag(),
-                    type: 'get',
-                    xmlns: 'newsletter',
-                    to: jid
-                },
-                content: [{ tag: 'message_updates', attrs: messageUpdateAttrs }]
-            });
-        },
-
         subscribeNewsletterUpdates: async (jid) => {
             const result = await query({
                 tag: 'iq',
@@ -463,6 +362,10 @@ newsletterSendPollVote: async (jid, parentServerId, options) => {
         // Convenience methods
         newsletterSendText: async (jid, text, options = {}) => {
             return newsletterSend(jid, { text }, sock.waUploadToServer, options);
-        }
+        },
+
+        // Channel API from newsletter-channel.js
+        ...channelApi,
+        mapNewsletterError
     };
 };

package/lib/Utils/messages.js

@@ -816,7 +816,8 @@ export const normalizeMessageContent = (content) => {
             message?.editedMessage ||
             message?.associatedChildMessage ||
             message?.groupStatusMessage ||
-            message?.groupStatusMessageV2);
+            message?.groupStatusMessageV2 ||
+            message?.newsletterAdminProfileStatusMessage);
     }
 };
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fixo-baileys",
   "type": "module",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",
@@ -17,7 +17,8 @@
     "lib/**/*",
     "WAProto/**/*",
     "engine-requirements.js",
-    "assets/**/*"
+    "assets/**/*",
+    "tools/**/*"
   ],
   "scripts": {
     "build": "tsc && tsc-esm-fix",

package/tools/capture-channel-status.js

@@ -0,0 +1,29 @@
+// capture-channel-status.js
+// Logs every raw stanza the bot receives/sends into capture.log so the real
+// "Channel Status" wire format can be inspected.
+//
+// Usage: in your bot, right after you create the socket:
+//
+//   import { attachCapture } from 'fixo-baileys/tools/capture-channel-status.js'
+//   const sock = makeWASocket({ ... })
+//   attachCapture(sock)
+//
+// Then post a real Channel Status from the phone (one text, one photo)
+// and send capture.log back (remove phone numbers if you like).
+import fs from 'fs'
+import { binaryNodeToString } from '../lib/WABinary/index.js'
+
+export const attachCapture = (sock, file = 'capture.log') => {
+    const out = fs.createWriteStream(file, { flags: 'a' })
+    sock.ws.on('frame', (frame) => {
+        if (frame instanceof Uint8Array) return
+        // skip noisy keep-alive / presence traffic
+        if (['presence', 'chatstate', 'receipt', 'ack'].includes(frame.tag)) return
+        try {
+            out.write(`\n[${new Date().toISOString()}] RECV\n${binaryNodeToString(frame)}\n`)
+        } catch (e) {
+            out.write(`\n[${new Date().toISOString()}] RECV (unprintable) ${e.message}\n`)
+        }
+    })
+    console.log(`capture started -> ${file}`)
+}