@kyyinfinite/baileys 1.0.0 → 2.1.0

package/lib/Kyyinfinite/Foad2.js

@@ -0,0 +1,466 @@
+import crypto from 'crypto';
+import { generateWAMessageFromContent } from '../Utils/messages.js';
+import { generateMessageIDV2 } from '../Utils/generics.js';
+import { BaseBuilder } from './BaseBuilder.js';
+import { Toolkit } from './Toolkit.js';
+import { AIRich } from './AIRich.js';
+
+class Foad2 extends BaseBuilder {
+    #client;
+
+    constructor(client, { dynamic = true } = {}) {
+        super();
+
+        if (!client) {
+            throw new Error('Socket is required');
+        }
+
+        this.#client = client;
+        this._dynamic = !!dynamic;
+
+        this._messageText = '';
+        this._previewTitle = 'Preview';
+        this._tabs = [];
+
+        this._responseId = crypto.randomUUID();
+        this._botResponseId = crypto.randomUUID();
+
+        this._lastMessageKey = null;
+    }
+
+    setResponseId(id) {
+        if (!id || typeof id !== 'string') {
+            throw new TypeError('Response ID must be a non-empty string');
+        }
+
+        this._responseId = id;
+        return this;
+    }
+
+    refreshResponseId() {
+        this._responseId = crypto.randomUUID();
+        return this;
+    }
+
+    setBotResponseId(id) {
+        if (!id || typeof id !== 'string') {
+            throw new TypeError('Bot response ID must be a non-empty string');
+        }
+
+        this._botResponseId = id;
+        return this;
+    }
+
+    refreshBotResponseId() {
+        this._botResponseId = crypto.randomUUID();
+        return this;
+    }
+
+    addTitle(text) {
+        if (typeof text !== 'string') {
+            throw new TypeError('Title must be a string');
+        }
+
+        this._messageText = text;
+        return this;
+    }
+
+    setPreviewTitle(title) {
+        if (typeof title !== 'string') {
+            throw new TypeError('Preview title must be a string');
+        }
+
+        this._previewTitle = title;
+        return this;
+    }
+
+    addHtml(
+        html,
+        {
+            title = 'Widget',
+            id,
+            url = 'https://example.com',
+            trustedSources = ['example.com'],
+            stepEntries = []
+        } = {}
+    ) {
+        if (typeof html !== 'string') {
+            throw new TypeError('HTML payload must be a string');
+        }
+
+        if (!html.trim()) {
+            throw new Error('HTML payload cannot be empty');
+        }
+
+        const tabId = id ?? `tab_${this._tabs.length}`;
+
+        if (this._tabs.some(tab => tab.id === tabId)) {
+            throw new Error(`Duplicate tab id: ${tabId}`);
+        }
+
+        this._tabs.push({
+            id: tabId,
+            tab_header: title,
+
+            sections: [
+                {
+                    __typename: 'GenAIUnifiedResponseSection',
+
+                    view_model: {
+                        __typename: 'GenAISingleLayoutViewModel',
+
+                        primitive: {
+                            __typename: 'GenAIaeacdsnwHtmlPrimitive',
+
+                            payload: html,
+
+                            url,
+
+                            trusted_sources: trustedSources
+                        }
+                    }
+                }
+            ],
+
+            step_entries: stepEntries
+        });
+
+        return this;
+    }
+
+    addTab(tab = {}) {
+        const {
+            id,
+            tab_header = 'Widget',
+            sections = [],
+            step_entries = []
+        } = tab;
+
+        if (!id || typeof id !== 'string') {
+            throw new TypeError('Tab id is required');
+        }
+
+        if (this._tabs.some(tab => tab.id === id)) {
+            throw new Error(`Duplicate tab id: ${id}`);
+        }
+
+        if (!Array.isArray(sections)) {
+            throw new TypeError('Tab sections must be an array');
+        }
+
+        if (!Array.isArray(step_entries)) {
+            throw new TypeError('Tab step_entries must be an array');
+        }
+
+        this._tabs.push({
+            id,
+            tab_header,
+            sections: structuredClone(sections),
+            step_entries: structuredClone(step_entries)
+        });
+
+        return this;
+    }
+
+    clearTabs() {
+        this._tabs = [];
+        return this;
+    }
+
+    get tabs() {
+        return structuredClone(this._tabs);
+    }
+
+    buildResponse() {
+        if (!this._tabs.length) {
+            throw new Error(
+                'Foad2 requires at least one HTML tab'
+            );
+        }
+
+        if (this._dynamic) {
+            this.refreshResponseId();
+            this.refreshBotResponseId();
+        }
+
+        /*
+         * FOAD2 / FULLSCREEN
+         *
+         * Perbedaan utama dengan Foad:
+         *
+         * Foad:
+         *   normal embedded widget
+         *
+         * Foad2:
+         *   fullscreen HTML surface
+         *
+         * Struktur embedded_screens tetap dipertahankan
+         * agar kompatibel dengan richResponseMessage.
+         */
+
+        return {
+            response_id: this._responseId,
+
+            sections: [
+                {
+                    __typename:
+                        'GenAIUnifiedResponseSection',
+
+                    view_model: {
+                        __typename:
+                            'GenAISingleLayoutViewModel',
+
+                        primitive: {
+                            __typename:
+                                'GenAIBotProgressStatusPrimitive',
+
+                            title:
+                                this._messageText ||
+                                'Popioo:*Click Me*',
+
+                            is_in_progress: true
+                        }
+                    }
+                }
+            ],
+
+            embedded_screens: [
+                {
+                    title: this._previewTitle,
+
+                    content: [
+                        {
+                            __typename:
+                                'FOAIDNixelButtonSheets',
+
+                            /*
+                             * FULLSCREEN MODE
+                             *
+                             * Flag tambahan untuk wrapper.
+                             *
+                             * Jika client/server mengabaikan field ini,
+                             * struktur HTML tetap valid.
+                             */
+
+                            display_mode: 'fullscreen',
+
+                            fullscreen: true,
+
+                            tabs: structuredClone(
+                                this._tabs
+                            )
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+
+    async build(
+        jid,
+        {
+            messageId,
+            ...options
+        } = {}
+    ) {
+        const responseData =
+            this.buildResponse();
+
+        const dataBase64 =
+            Buffer
+                .from(
+                    JSON.stringify(responseData)
+                )
+                .toString('base64');
+
+        return generateWAMessageFromContent(
+            jid,
+
+            {
+                messageContextInfo: {
+                    deviceListMetadata: {},
+
+                    deviceListMetadataVersion: 2,
+
+                    botMetadata: {
+                        messageDisclaimerText:
+                            this._title || '',
+
+                        botResponseId:
+                            this._botResponseId,
+
+                        verificationMetadata:
+                            AIRich.generateVerificationMetadata()
+                    }
+                },
+
+                ...this._extraPayload,
+
+                botForwardedMessage: {
+                    message: {
+                        richResponseMessage: {
+                            messageType: 1,
+
+                            submessages:
+                                this._messageText
+                                    ? [
+                                        {
+                                            messageType: 2,
+
+                                            messageText:
+                                                this._messageText
+                                        }
+                                    ]
+                                    : [],
+
+                            unifiedResponse: {
+                                data: dataBase64
+                            },
+
+                            contextInfo: {
+                                forwardingScore: 1,
+
+                                isForwarded: true,
+
+                                forwardedAiBotMessageInfo: {
+                                    botJid:
+                                        '867051314767696@bot'
+                                },
+
+                                forwardOrigin: 4
+                            }
+                        }
+                    }
+                }
+            },
+
+            {
+                messageId:
+                    messageId ||
+                    generateMessageIDV2(),
+
+                ...options
+            }
+        );
+    }
+
+    async send(
+        jid,
+        {
+            messageId,
+            ...options
+        } = {}
+    ) {
+        const msg =
+            await this.build(
+                jid,
+                {
+                    messageId,
+                    ...options
+                }
+            );
+
+        await this.#client.relayMessage(
+            msg.key.remoteJid,
+
+            msg.message,
+
+            {
+                messageId: msg.key.id,
+                ...options
+            }
+        );
+
+        this._lastMessageKey =
+            msg.key;
+
+        return msg;
+    }
+
+    async sendEdit(
+        jid,
+        id,
+        {
+            msg,
+            messageId,
+            ...options
+        } = {}
+    ) {
+        jid =
+            jid ??
+            this._lastMessageKey?.remoteJid;
+
+        id =
+            id ??
+            this._lastMessageKey?.id;
+
+        if (!jid) {
+            throw new Error(
+                'JID is required'
+            );
+        }
+
+        if (!id) {
+            throw new Error(
+                'Message id is required'
+            );
+        }
+
+        const source =
+            msg ??
+            (
+                await this.build(
+                    jid,
+                    options
+                )
+            ).message;
+
+        const editedMessage =
+            await generateWAMessageFromContent(
+                jid,
+
+                {
+                    botForwardedMessage: {
+                        message: {
+                            protocolMessage: {
+                                key: {
+                                    remoteJid: jid,
+                                    fromMe: true,
+                                    id
+                                },
+
+                                type: 14,
+
+                                editedMessage:
+                                    source
+                            }
+                        }
+                    }
+                },
+
+                {
+                    messageId:
+                        messageId ||
+                        generateMessageIDV2(),
+
+                    ...options
+                }
+            );
+
+        await this.#client.relayMessage(
+            jid,
+
+            editedMessage.message,
+
+            {
+                messageId:
+                    editedMessage.key.id
+            }
+        );
+
+        return editedMessage;
+    }
+}
+
+
+export { Foad2 };

package/lib/Kyyinfinite/Simple/AIBuilder.js

@@ -0,0 +1,18 @@
+import { AIRich } from '../AIRich.js'
+import { proxyBuilder } from './SimpleBuilder.js'
+
+const aliases = {
+  title: 'setTitle',
+  subtitle: 'setSubtitle',
+  body: 'setBody',
+  footer: 'setFooter',
+  context: 'setContextInfo',
+  payload: 'addPayload',
+  text: 'addText'
+}
+
+export function createAIBuilder(sock, ...args) {
+  return proxyBuilder({ sock, raw: new AIRich(sock, ...args) }, aliases)
+}
+
+export { AIRich }

package/lib/Kyyinfinite/Simple/BuilderFactories.js

@@ -0,0 +1,17 @@
+import { Button } from '../Button.js'
+import { ButtonV2 } from '../ButtonV2.js'
+import { Carousel } from '../Carousel.js'
+import { AIRich } from '../AIRich.js'
+import { Foad } from '../Foad.js'
+import { Foad2 } from '../Foad2.js'
+import { proxyBuilder } from './SimpleBuilder.js'
+
+const wrap = (sock, raw, aliases = {}) => proxyBuilder({ sock, raw }, aliases)
+const common = { title: 'setTitle', subtitle: 'setSubtitle', body: 'setBody', text: 'setBody', footer: 'setFooter', context: 'setContextInfo', payload: 'addPayload' }
+
+export const createButtonBuilder = (sock, ...args) => wrap(sock, new Button(sock, ...args), common)
+export const createButtonV2Builder = (sock, ...args) => wrap(sock, new ButtonV2(sock, ...args), common)
+export const createCarouselBuilder = (sock, ...args) => wrap(sock, new Carousel(sock, ...args), common)
+export const createAIBuilder = (sock, ...args) => wrap(sock, new AIRich(sock, ...args), { ...common, text: 'addText' })
+export const createFoadBuilder = (sock, ...args) => wrap(sock, new Foad(sock, ...args), { ...common, title: 'addTitle', text: 'addText' })
+export const createFoad2Builder = (sock, ...args) => wrap(sock, new Foad2(sock, ...args), { ...common, title: 'addTitle', text: 'addText' })

package/lib/Kyyinfinite/Simple/ButtonBuilder.js

@@ -0,0 +1,107 @@
+import { Button } from '../Button.js'
+import { ButtonV2 } from '../ButtonV2.js'
+import { proxyBuilder } from './SimpleBuilder.js'
+
+const aliases = {
+  // BaseBuilder
+  title: 'setTitle',
+  subtitle: 'setSubtitle',
+  body: 'setBody',
+  text: 'setBody',
+  footer: 'setFooter',
+  context: 'setContextInfo',
+  payload: 'addPayload',
+
+  // Media
+  image: 'setImage',
+  document: 'setDocument',
+  media: 'setMedia',
+
+  // Button collection
+  clear: 'clearButtons',
+  params: 'setParams',
+
+  // Quick reply
+  reply: 'addReply',
+  quickReply: 'addReply',
+
+  // CTA
+  call: 'addCall',
+  url: 'addUrl',
+  copy: 'addCopy',
+  ctaCopy: 'addCopy',
+  ctaUrl: 'addUrl',
+  ctaCall: 'addCall',
+  // Backwards-friendly alias for the spelling requested in early examples.
+  coppy: 'addCopy',
+  reminder: 'addReminder',
+  cancelReminder: 'addCancelReminder',
+  address: 'addAddress',
+  location: 'addLocation',
+
+  // List / selection
+  select: 'addSelection',
+  section: 'makeSection',
+  row: 'makeRow'
+}
+
+export function createButtonBuilder(sock, ...args) {
+  const builder = proxyBuilder({
+    sock,
+    raw: new Button(sock, ...args)
+  }, aliases)
+
+  // Friendly Simple API:
+  // .addButton(label, id) => quick reply
+  // The original Button.addButton(name, params) remains untouched and is
+  // still available through builder.raw / api.raw.Button.
+  return new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (prop === 'addButton') {
+        return (displayText = '', id = '', options = {}) => {
+          const value = target.raw.addReply(
+            displayText,
+            id,
+            options
+          )
+          return value === target.raw ? receiver : value
+        }
+      }
+
+      // Explicit CTA aliases make the public API self-documenting:
+      // .copy(), .url(), .call()
+      // They are resolved here so they always return the facade for chaining.
+      if (prop === 'copy' || prop === 'coppy' || prop === 'ctaCopy') {
+        return (...args) => {
+          const value = target.raw.addCopy(...args)
+          return value === target.raw ? receiver : value
+        }
+      }
+
+      if (prop === 'url' || prop === 'ctaUrl') {
+        return (...args) => {
+          const value = target.raw.addUrl(...args)
+          return value === target.raw ? receiver : value
+        }
+      }
+
+      if (prop === 'call' || prop === 'ctaCall') {
+        return (...args) => {
+          const value = target.raw.addCall(...args)
+          return value === target.raw ? receiver : value
+        }
+      }
+
+      return Reflect.get(target, prop, receiver)
+    }
+  })
+}
+
+export function createButtonV2Builder(sock, ...args) {
+  return proxyBuilder({
+    sock,
+    raw: new ButtonV2(sock, ...args)
+  }, aliases)
+}
+
+export { Button, ButtonV2 }