fixo-baileys 1.0.7 → 1.0.8

package/README.md

@@ -956,17 +956,100 @@ 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.
 
 **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/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 {
@@ -1283,6 +1284,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,
@@ -1326,14 +1342,8 @@ export const makeMessagesSocket = (config) => {
                     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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fixo-baileys",
   "type": "module",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",