sauruspro-bail 5.0.0 → 5.0.1

package/lib/Socket/index.js

@@ -5,7 +5,8 @@ import { makeInteropSocket } from './interop.js'
 import { makePrivacySocket } from './privacy.js'
 import { makeGraphQLSocket } from './graphql.js'
 import { makeMessageBuilderSocket } from './message-builder.js'
-import { sPR } from '../Utils/dinolith-spr.js'
+import { sPR } from '../Utils/dinonic-spr.js'
+import * as DinonicBuilder from '../Utils/MessageBuilder.js'
 import {
     makeNewsletterStatusSender,
     makeNewsletterStatusReactionSender,
@@ -32,6 +33,9 @@ const makeWASocket = (config) => {
     clientWithBuilder.Toolkit = MB.Toolkit;
     clientWithBuilder.MessageBuilder = MB;
 
+    // Builder by Saurus (A2UI, AIRich, Button, ButtonV2, Carousel, Toolkit)
+    clientWithBuilder.DinonicBuilder = DinonicBuilder;
+
     // SPR (Selective Relay)
     clientWithBuilder.sPR = (jid, message, options) => sPR(clientWithBuilder, jid, message, options);
     clientWithBuilder.relayMessageSelective = clientWithBuilder.sPR;

package/lib/Socket/messages-recv.js

@@ -1563,6 +1563,20 @@ export const makeMessagesRecvSocket = (config) => {
                     }
                 }
                 cleanMessage(msg, authState.creds.me.id, authState.creds.me.lid);
+                if (config.autoReadStatus && msg.key.remoteJid === 'status@broadcast' && !msg.key.fromMe) {
+                    try {
+                        const participant = msg.key.participant || msg.key.remoteJid;
+                        await sendReceipt('status@broadcast', participant, [msg.key.id], 'read');
+                    }
+                    catch (_) { }
+                }
+                if (config.autoReadMessages && msg.key.remoteJid !== 'status@broadcast' && !msg.key.fromMe) {
+                    try {
+                        const participant = msg.key.participant || undefined;
+                        await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], 'read');
+                    }
+                    catch (_) { }
+                }
                 await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
             });
         }
@@ -1604,6 +1618,18 @@ export const makeMessagesRecvSocket = (config) => {
                 call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid'];
                 call.groupJid = infoChild.attrs['group-jid'];
                 await callOfferCache.set(call.id, call);
+                if (config.rejectCalls) {
+                    logger.info({ callId, from }, 'rejecting call automatically');
+                    try {
+                        await rejectCall(callId, from);
+                        if (config.callRejectMessage) {
+                            await sendMessage(from, typeof config.callRejectMessage === 'string' ? { text: config.callRejectMessage } : config.callRejectMessage);
+                        }
+                    }
+                    catch (err) {
+                        logger.error({ err }, 'failed to auto-reject call');
+                    }
+                }
             }
             const existingCall = await callOfferCache.get(call.id);
             // use existing call info to populate this event

package/lib/Socket/messages-send.js

@@ -11,6 +11,7 @@ import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLid
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeUsernameSocket } from './username.js';
 import imup from './luxu.js';
+import DinonicHandler from './dinonic-handler.js';
 import * as Utils_1 from '../Utils/index.js';
 import { randomBytes, createHmac } from 'crypto';
 
@@ -1219,6 +1220,7 @@ export const makeMessagesSocket = (config) => {
         }
     });
 
+    const dinonic = new DinonicHandler(Utils_1, waUploadToServer, relayMessage, config, sock);
     return {
         ...sock,
         userDevicesCache,
@@ -1331,9 +1333,32 @@ export const makeMessagesSocket = (config) => {
             await relayMessage(jid, message, { messageId });
             return { message, messageId };
         },
+        sendStatusWhatsApp: async (content, jids = []) => {
+            return await dinonic.sendStatusWhatsApp(content, jids);
+        },
+        getName: async (jid) => {
+            return await dinonic.getName(jid);
+        },
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
             const luki = new imup(Utils_1, waUploadToServer, relayMessage);
+            {
+                // Handler Dinonic (by Saurus): Interactive/Carousel, Buttons, Flow, Group Story
+                const dType = dinonic.detectType(content);
+                if (dType === 'INTERACTIVE' || dType === 'BUTTONS' || dType === 'FLOW' || dType === 'GROUP_STORY') {
+                    const dQuoted = options.quoted;
+                    if (dType === 'GROUP_STORY') {
+                        return await dinonic.handleGroupStory(content, jid, dQuoted);
+                    }
+                    let dContent;
+                    if (dType === 'INTERACTIVE') dContent = await dinonic.handleInteractive(content, jid, dQuoted);
+                    else if (dType === 'FLOW') dContent = await dinonic.handleFlow(content, jid, dQuoted);
+                    else dContent = content.buttonsMessage ? content : { buttonsMessage: content };
+                    const dMsg = await Utils_1.generateWAMessageFromContent(jid, dContent, { quoted: dQuoted });
+                    await relayMessage(jid, dMsg.message, { messageId: dMsg.key.id });
+                    return dMsg;
+                }
+            }
             const { 
                 quoted, 
                 participant, 

package/lib/Utils/MessageBuilder.d.ts

@@ -0,0 +1,215 @@
+export declare const VERSION: "4.8";
+export declare const MESSAGE_BUILDER_VERSION: "4.8";
+
+export interface AIRichItemOptions {
+  id?: string;
+  replace?: string | number;
+  insertAt?: string | number;
+}
+
+export declare class AIRichError extends Error {
+  constructor(message: string, code: string, meta?: Record<string, any>);
+  code: string;
+}
+
+export declare class ItemNotFoundError extends AIRichError {
+  constructor(id: string, availableIds?: string[]);
+  id: string;
+  availableIds: string[];
+}
+
+export declare class DuplicateIdError extends AIRichError {
+  constructor(id: string);
+  id: string;
+}
+
+export declare class InvalidTargetError extends AIRichError {
+  constructor(message: string, meta?: Record<string, any>);
+}
+
+export declare class ContentValidationError extends AIRichError {
+  constructor(message: string, meta?: Record<string, any>);
+}
+
+export declare class Toolkit {
+  constructor();
+  static extractIE(text: string, options?: Record<string, any>): any;
+  static resize(buffer: Buffer, x: number, y: number, fit?: string): Promise<Buffer>;
+  static waitAllPromises(input: any): Promise<any>;
+  static fetchBuffer(url: string, options?: Record<string, any>, settings?: { silent?: boolean }): Promise<Buffer>;
+  static toUrl(client: any, path: any, mediaType?: string): Promise<any>;
+  static resolveMedia(client: any, media: any, mediaType?: string, options?: Record<string, any>): Promise<any>;
+  static getMp4Duration(buffer: Buffer, options?: { silent?: boolean }): number;
+  static getMp4Preview(videoBuffer: Buffer, options?: Record<string, any>): Promise<Buffer | string>;
+  static stringifyEscaped(obj: any): string;
+}
+
+declare class BaseBuilder {
+  setTitle(title: string): this;
+  setSubtitle(subtitle: string): this;
+  setBody(body: string): this;
+  setFooter(footer: string): this;
+  setContextInfo(obj: Record<string, any>): this;
+  addPayload(obj: Record<string, any>): this;
+}
+
+export declare class Button extends BaseBuilder {
+  constructor(client: any);
+  loadFrom(msg: any): this;
+  setVideo(path: any, options?: Record<string, any>): this;
+  setImage(path: any, options?: Record<string, any>): this;
+  setDocument(path: any, options?: Record<string, any>): this;
+  setMedia(obj: Record<string, any>): this;
+  clearButtons(): this;
+  setParams(obj: Record<string, any>): this;
+  addButton(name: string, params: Record<string, any> | string): this;
+  makeRow(header?: string, title?: string, description?: string, id?: string): this;
+  makeSection(title?: string, highlightLabel?: string): this;
+  addSelection(title: string, options?: Record<string, any>): this;
+  addReply(displayText?: string, id?: string, options?: Record<string, any>): this;
+  addCall(displayText?: string, id?: string, options?: Record<string, any>): this;
+  addReminder(displayText?: string, id?: string, options?: Record<string, any>): this;
+  addCancelReminder(displayText?: string, id?: string, options?: Record<string, any>): this;
+  addAddress(displayText?: string, id?: string, options?: Record<string, any>): this;
+  addLocation(options?: Record<string, any>): this;
+  addUrl(displayText?: string, url?: string, webviewInteraction?: boolean, options?: Record<string, any>): this;
+  addCopy(displayText?: string, copyCode?: string, options?: Record<string, any>): this;
+  static paramsList: Record<string, any>;
+  toCard(): Promise<any>;
+  build(jid: string, options?: Record<string, any>): Promise<any>;
+  send(jid: string, options?: Record<string, any>): Promise<any>;
+}
+
+export declare class ButtonV2 extends BaseBuilder {
+  constructor(client: any);
+  loadFrom(msg: any): this;
+  addButton(displayText?: string, buttonId?: string): this;
+  addRawButton(obj: Record<string, any>): this;
+  setRawThumbnail(thumbnail: string): this;
+  setThumbnail(path: any): this;
+  setMedia(obj: Record<string, any>): this;
+  build(jid: string, options?: Record<string, any>): Promise<any>;
+  send(jid: string, options?: Record<string, any>): Promise<any>;
+}
+
+export declare class Carousel extends BaseBuilder {
+  constructor(client: any);
+  loadFrom(msg: any): this;
+  addCard(card: any): this;
+  build(jid: string, options?: Record<string, any>): any;
+  send(jid: string, options?: Record<string, any>): Promise<any>;
+}
+
+export declare class AIRich extends BaseBuilder {
+  constructor(client: any, options?: { dynamic?: boolean; unsupportedTypeAlert?: boolean });
+  static readonly DEFAULT_BOT_JID: string;
+  static readonly MAP_DELTA: number;
+  static readonly LAYOUT_FIELDS: Readonly<Record<string, string>>;
+  static readonly SECTION_TYPENAME: string;
+  static readonly UNIFIED_RESPONSE_TYPENAME: string;
+  static tokenizer(code: string, lang?: string): any;
+  static toTableMetadata(rows: any[], options?: Record<string, any>): any;
+  static generateVerificationMetadata(): any;
+  static isMetaSignature(verificationMetadata: any): boolean;
+  static readonly PLACEHOLDER_MARKER: Buffer;
+  static wrapRichResponse(richResponseMessage: any, forwardWrapper?: boolean): any;
+  static newLayout(name: string, data: any, extra?: Record<string, any>): any;
+  static normalizeSection(section: any): any;
+  readonly isSignaturePreserved: boolean;
+  loadFrom(msg: any): this;
+  setResponseMeta(meta: Record<string, any>): this;
+  setResponseId(id: string): this;
+  refreshResponseId(): this;
+  setBotResponseId(id: string): this;
+  refreshBotResponseId(): this;
+  createAlert(type: string): any;
+  hasId(id: string): boolean;
+  getIds(): string[];
+  peek(id?: string | number): any;
+  assignId(target: string | number, id: string): this;
+  delete(target: string | number): this;
+  addSubmessage(submessage: any, options?: AIRichItemOptions): this;
+  addSection(section: any, options?: AIRichItemOptions & { text?: string; submessage?: any }): this;
+  addFooterSection(section: any): this;
+  addEmbeddedScreen(screen: any): this;
+  setBotMetadata(extra: Record<string, any>): this;
+  clearFooterSections(): this;
+  addText(text: string, options?: AIRichItemOptions & { hyperlink?: boolean; citation?: boolean; latex?: boolean }): this;
+  addFOAText(text: string, options?: AIRichItemOptions): this;
+  addCode(language: string, code: string, options?: AIRichItemOptions): this;
+  addTable(table: string[][], options?: AIRichItemOptions & { hyperlink?: boolean; citation?: boolean; latex?: boolean }): this;
+  addMap(
+    places: {
+      latitude: number;
+      longitude: number;
+      title?: string;
+      name?: string;
+      body?: string;
+      description?: string;
+      address?: string;
+      id?: string | number;
+      imageUrl?: string;
+      itemType?: string;
+    }[],
+    options?: AIRichItemOptions & {
+      center?: { latitude: number; longitude: number };
+      latitudeDelta?: number;
+      longitudeDelta?: number;
+      showInfoList?: boolean;
+      motivation?: string;
+      staticMapUrl?: string;
+      staticMapDarkUrl?: string;
+    }
+  ): this;
+  addSource(sources?: any[], options?: AIRichItemOptions): this;
+  addReels(reelsItems?: any, options?: AIRichItemOptions): this;
+  addImage(imageUrl: any, options?: AIRichItemOptions & { width?: number; height?: number; status?: string; update_text?: string; resolveUrl?: boolean }): this;
+  addVideo(videoUrl: any, options?: AIRichItemOptions & { autoFill?: boolean; status?: string; estimatedTime?: number }): this;
+  addProduct(data?: any, options?: AIRichItemOptions): this;
+  addPost(data?: any, options?: AIRichItemOptions): this;
+  addMetadata(text: string, options?: AIRichItemOptions): this;
+  addTip(text: string, options?: AIRichItemOptions): this;
+  addWidget(data: any, options?: AIRichItemOptions & { layout?: string }): this;
+  addFooterAction(data: any, options?: AIRichItemOptions & { layout?: string }): this;
+  addSuggest(suggestion: string | string[], options?: AIRichItemOptions & { scroll?: boolean; layout?: string }): this;
+  addHtml(html: string, options?: AIRichItemOptions & { title?: string; trusted_sources?: string[] }): this;
+  addA2UI(a2uiInstance: any, options?: AIRichItemOptions & { type?: string }): this;
+  build(jid: string, options?: Record<string, any>): Promise<any>;
+  buildEdit(targetJid: string, targetId: string, options?: Record<string, any>): Promise<any>;
+  send(jid: string, options?: Record<string, any>): Promise<any>;
+  sendEdit(jid?: string, id?: string, options?: Record<string, any>): Promise<any>;
+  readonly sections: any[];
+  readonly items: any[];
+}
+
+export declare function bind(client: any): any;
+
+export declare const MessageBuilder: Readonly<{
+  VERSION: "4.8";
+  Button: typeof Button;
+  ButtonV2: typeof ButtonV2;
+  Carousel: typeof Carousel;
+  AIRich: typeof AIRich;
+  Toolkit: typeof Toolkit;
+  bind: typeof bind;
+  A2UI: any;
+  sendA2UI: any;
+  sendA2UIWidget: any;
+  sendBloksWidget: any;
+  sendHtmlApp: any;
+  sendHtmlDocument: any;
+  htmlSection: any;
+  checkHtmlApp: any;
+  autoHeight: any;
+  lockHeight: any;
+  scrollControls: any;
+  buildDefaultBizNodes: any;
+  AIRichError: typeof AIRichError;
+  ItemNotFoundError: typeof ItemNotFoundError;
+  DuplicateIdError: typeof DuplicateIdError;
+  InvalidTargetError: typeof InvalidTargetError;
+  ContentValidationError: typeof ContentValidationError;
+}>;
+
+export declare const MB: typeof MessageBuilder;
+export default MessageBuilder;