sauruspro-bail 5.0.2-alpha.spr.test → 5.0.3

package/lib/Utils/crypto.js

@@ -1,6 +1,7 @@
 import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes } from 'crypto';
 import * as curve from 'libsignal/src/curve.js';
 import { KEY_BUNDLE_TYPE } from '../Defaults/index.js';
+import { getNativeCrypto } from './native-backend.js';
 export { md5, hkdf } from 'whatsapp-rust-bridge';
 // insure browser & node compatibility
 const { subtle } = globalThis.crypto;
@@ -16,11 +17,34 @@ export const Curve = {
         };
     },
     sharedKey: (privateKey, publicKey) => {
+        const native = getNativeCrypto().x25519;
+        if (native) {
+            try {
+                return Buffer.from(native(privateKey, publicKey.length === 33 ? publicKey.subarray(1) : publicKey));
+            }
+            catch { /* fallback ke JS */ }
+        }
         const shared = curve.calculateAgreement(generateSignalPubKey(publicKey), privateKey);
         return Buffer.from(shared);
     },
-    sign: (privateKey, buf) => curve.calculateSignature(privateKey, buf),
+    sign: (privateKey, buf) => {
+        const native = getNativeCrypto().xeddsaSign;
+        if (native) {
+            try {
+                return Buffer.from(native(privateKey, buf));
+            }
+            catch { /* fallback ke JS */ }
+        }
+        return curve.calculateSignature(privateKey, buf);
+    },
     verify: (pubKey, message, signature) => {
+        const native = getNativeCrypto().xeddsaVerify;
+        if (native) {
+            try {
+                return !!native(pubKey.length === 33 ? pubKey.subarray(1) : pubKey, message, signature);
+            }
+            catch { /* fallback ke JS */ }
+        }
         try {
             curve.verifySignature(generateSignalPubKey(pubKey), message, signature);
             return true;

package/lib/Utils/greeting-card.d.ts

@@ -0,0 +1,15 @@
+export interface GreetingCardOptions {
+    text?: string;
+    title?: string;
+    greeting?: string;
+    imageUrl?: string;
+    contactUrl?: string;
+    thumbnail?: Buffer;
+    sourceApp?: string;
+    ref?: string;
+    mentions?: string[];
+    /** override field externalAdReply apa pun */
+    adReply?: Record<string, any>;
+}
+export declare const buildGreetingCardContent: (opts?: GreetingCardOptions) => any;
+export declare const sendGreetingCard: (sock: any, jid: string, opts?: GreetingCardOptions, sendOptions?: Record<string, any>) => Promise<any>;

package/lib/Utils/greeting-card.js

@@ -0,0 +1,70 @@
+// Greeting Card (/buss) - diadaptasi dari zapo-js.
+// Pesan teks + contextInfo.externalAdReply. Kartu sapaan hanya terlihat di WhatsApp Business;
+// user WhatsApp biasa hanya melihat teks chat.
+import { randomBytes } from 'crypto';
+import { generateWAMessageFromContent } from './messages.js';
+
+export const buildGreetingCardContent = (opts = {}) => {
+    const {
+        text = '',
+        title = '',
+        greeting = 'Hi Business',
+        imageUrl = '',
+        contactUrl = '',
+        thumbnail,
+        sourceApp = 'myapp',
+        ref = 'referencia',
+        mentions,
+        adReply = {}
+    } = opts;
+    return {
+        extendedTextMessage: {
+            text,
+            contextInfo: {
+                ...(mentions?.length ? { mentionedJid: mentions } : {}),
+                externalAdReply: {
+                    title,
+                    body: greeting,
+                    mediaType: 1,
+                    thumbnailUrl: imageUrl,
+                    thumbnail: thumbnail ?? Buffer.alloc(0),
+                    sourceType: 'whatsapp',
+                    sourceId: String(randomBytes(4).readUInt32BE(0)),
+                    sourceUrl: contactUrl,
+                    containsAutoReply: false,
+                    renderLargerThumbnail: false,
+                    showAdAttribution: false,
+                    ctwaClid: `clid${randomBytes(8).toString('hex')}`,
+                    ref,
+                    clickToWhatsappCall: true,
+                    adContextPreviewDismissed: false,
+                    sourceApp,
+                    automatedGreetingMessageShown: true,
+                    greetingMessageBody: greeting,
+                    ctaPayload: `payload${randomBytes(8).toString('hex')}`,
+                    disableNudge: true,
+                    originalImageUrl: imageUrl,
+                    wtwaAdFormat: false,
+                    containsCtwaFlowsAutoReply: false,
+                    agmThumbnailStrategy: 0,
+                    agmTitleStrategy: 0,
+                    agmSubtitleStrategy: 0,
+                    agmHeaderInteractionStrategy: 0,
+                    ...adReply
+                }
+            }
+        }
+    };
+};
+
+export const sendGreetingCard = async (sock, jid, opts = {}, sendOptions = {}) => {
+    const content = buildGreetingCardContent(opts);
+    const userJid = sock.authState?.creds?.me?.id ?? sock.user?.id;
+    const msg = generateWAMessageFromContent(jid, content, {
+        userJid,
+        ...(sendOptions.messageId ? { messageId: sendOptions.messageId } : {}),
+        ...(sendOptions.quoted ? { quoted: sendOptions.quoted } : {})
+    });
+    await sock.relayMessage(jid, msg.message, { messageId: msg.key.id, ...sendOptions });
+    return msg;
+};

package/lib/Utils/group-history.d.ts

@@ -0,0 +1,4 @@
+export declare const GROUP_HISTORY_FIELDS: Readonly<{ MESSAGES: 1; OUT_OF_WINDOW_PINNED_MESSAGES: 4 }>;
+export declare function encodeGroupHistoryBundle(messages: any[], outOfWindowPinnedMessages?: any[]): Promise<{ compressed: Buffer; encoded: Uint8Array }>;
+export declare function decodeGroupHistoryBundle(blob: Uint8Array): Promise<any>;
+export declare function streamGroupHistoryBundle(inflated: Uint8Array, onMessage: (msg: any, isOutOfWindowPinned: boolean) => void | Promise<void>, maxRecordBytes?: number): Promise<void>;

package/lib/Utils/group-history.js

@@ -0,0 +1,58 @@
+// Group History Bundle - diadaptasi dari zapo-js (MIT).
+// Serialize/deserialize riwayat pesan grup yang dibagikan ke anggota baru.
+import { promisify } from 'util';
+import { deflate, unzip } from 'zlib';
+import $protobuf from 'protobufjs/minimal.js';
+import { proto } from '../../WAProto/index.js';
+
+const deflateAsync = promisify(deflate);
+const unzipAsync = promisify(unzip);
+
+export const GROUP_HISTORY_FIELDS = Object.freeze({
+    MESSAGES: 1,
+    OUT_OF_WINDOW_PINNED_MESSAGES: 4
+});
+
+/** Encode pesan -> payload `GroupHistory` terkompres (zlib). */
+export async function encodeGroupHistoryBundle(messages, outOfWindowPinnedMessages) {
+    const encoded = proto.GroupHistory.encode({
+        messages,
+        outOfWindowPinnedMessages: outOfWindowPinnedMessages?.length ? outOfWindowPinnedMessages : undefined
+    }).finish();
+    const compressed = await deflateAsync(encoded);
+    return { compressed, encoded };
+}
+
+/** Inflate + decode blob bundle hasil download. */
+export async function decodeGroupHistoryBundle(blob) {
+    const inflated = await unzipAsync(blob);
+    return proto.GroupHistory.decode(inflated);
+}
+
+/**
+ * Baca bundle (sudah di-inflate) satu pesan per satu pesan, tanpa decode seluruh bundle sekaligus.
+ * onMessage(webMessageInfo, isOutOfWindowPinned)
+ */
+export async function streamGroupHistoryBundle(inflated, onMessage, maxRecordBytes) {
+    const reader = $protobuf.Reader.create(inflated);
+    while (reader.pos < reader.len) {
+        const tag = reader.uint32();
+        const fieldNumber = tag >>> 3;
+        const wireType = tag & 7;
+        if (wireType === 2) {
+            const bytes = reader.bytes();
+            if (maxRecordBytes !== undefined && bytes.length > maxRecordBytes) {
+                throw new Error(`group history record exceeds ${maxRecordBytes} bytes`);
+            }
+            if (fieldNumber === GROUP_HISTORY_FIELDS.MESSAGES) {
+                await onMessage(proto.WebMessageInfo.decode(bytes), false);
+            }
+            else if (fieldNumber === GROUP_HISTORY_FIELDS.OUT_OF_WINDOW_PINNED_MESSAGES) {
+                await onMessage(proto.WebMessageInfo.decode(bytes), true);
+            }
+        }
+        else {
+            reader.skipType(wireType);
+        }
+    }
+}

package/lib/Utils/index.js

@@ -23,6 +23,12 @@ export * from './stanza-ack.js';
 export * from './message-composer.js';
 export * from './newsletter-status.js';
 export { sPR, selectiveRelay, sPRPrivate, sPRBroadcast, getSPRTargets, loadSPRAvatars, createOneShotSenderKey, SPR_LIMITS, SPR_TEXT } from './dinonic-spr.js';
+export * from './group-history.js';
+export { definePlugin, makePluginHost } from './plugins.js';
+export { makePresence, makeProfile } from './presence-profile.js';
+export { resolveNativeBackend, getNativeCrypto, isNativeCryptoActive } from './native-backend.js';
+export * as MetaAIBot from './meta-ai-bot.js';
+export { sendGreetingCard, buildGreetingCardContent } from './greeting-card.js';
 //# sourceMappingURL=index.js.map
 export * from './a2ui.js';
 export * from './html-app.js';

package/lib/Utils/meta-ai-bot.d.ts

@@ -0,0 +1,10 @@
+export declare const BOT_SERVER: 'bot';
+export declare const BOT_KNOWN_JIDS: Readonly<Record<'META_AI_PN' | 'META_AI_FBID' | 'META_AI_TEE_FBID' | 'META_AI_SIDECHAT_FBID' | 'MANUS_FBID' | 'HATCH_FBID', string>>;
+export declare const isBotServerJid: (jid: string) => boolean;
+export declare function genBotMsgSecret(parentMessageSecret: Uint8Array): Buffer;
+export declare function deriveBotChunkKey(input: { botMsgSecret: Uint8Array; saltId: string; targetSenderJid: string; authorJid: string }): Buffer;
+export declare function decryptBotChunk(input: { parentMessageSecret: Uint8Array; saltId: string; targetSenderJid: string; authorJid: string; encIv: Uint8Array; encPayload: Uint8Array }): Buffer;
+export declare function attachBotMetadata(message: any, input?: { personaId?: string; invokerJid?: string; capabilities?: any[] }): any;
+export declare function attachBotThread(message: any, input: { remoteJid: string; aiThreadId: string; threadType?: number }): any;
+export declare function extractInvokedBotJid(message: any): string | null;
+export declare function buildBotInvokeProtoCopy(message: any, botMessageSecret?: Uint8Array): any;

package/lib/Utils/meta-ai-bot.js

@@ -0,0 +1,94 @@
+// Meta AI Bot helpers - diadaptasi dari zapo-js (MIT).
+// Metadata bot, thread AI, dekripsi chunk balasan bot, deteksi bot yang di-invoke.
+import { hkdfSync } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { aesDecryptGCM } from './crypto.js';
+
+export const BOT_SERVER = 'bot';
+export const BOT_HKDF_INFO = Buffer.from('Bot Message');
+export const BOT_MSG_SECRET_BYTES = 32;
+export const BOT_KNOWN_JIDS = Object.freeze({
+    META_AI_PN: '13135550002@s.whatsapp.net',
+    META_AI_FBID: `867051314767696@${BOT_SERVER}`,
+    META_AI_TEE_FBID: `1273596044787272@${BOT_SERVER}`,
+    META_AI_SIDECHAT_FBID: `867051314767696555@${BOT_SERVER}`,
+    MANUS_FBID: `1807055946647696@${BOT_SERVER}`,
+    HATCH_FBID: `1807055946647697@${BOT_SERVER}`
+});
+
+export const isBotServerJid = (jid) => typeof jid === 'string' && jid.endsWith(`@${BOT_SERVER}`);
+
+const hkdf = (ikm, info) => Buffer.from(hkdfSync('sha256', ikm, Buffer.alloc(0), info, BOT_MSG_SECRET_BYTES));
+
+export function genBotMsgSecret(parentMessageSecret) {
+    const ikm = Buffer.from(parentMessageSecret);
+    if (ikm.length !== 32) {
+        throw new Error(`bot parent message secret must be 32 bytes (got ${ikm.length})`);
+    }
+    return hkdf(ikm, BOT_HKDF_INFO);
+}
+
+export function deriveBotChunkKey({ botMsgSecret, saltId, targetSenderJid, authorJid }) {
+    if (!saltId) throw new Error('bot chunk salt id must be a non-empty string');
+    if (!targetSenderJid) throw new Error('bot chunk target sender jid must be a non-empty string');
+    if (!authorJid) throw new Error('bot chunk author jid must be a non-empty string');
+    return hkdf(Buffer.from(botMsgSecret), Buffer.from(saltId + targetSenderJid + authorJid));
+}
+
+/** Dekripsi chunk balasan bot (AES-GCM, AAD = saltId + NUL + authorJid). */
+export function decryptBotChunk({ parentMessageSecret, saltId, targetSenderJid, authorJid, encIv, encPayload }) {
+    const botMsgSecret = genBotMsgSecret(parentMessageSecret);
+    const key = deriveBotChunkKey({ botMsgSecret, saltId, targetSenderJid, authorJid });
+    const aad = Buffer.from(`${saltId}\u0000${authorJid}`);
+    return aesDecryptGCM(Buffer.from(encPayload), key, Buffer.from(encIv), aad);
+}
+
+export function attachBotMetadata(message, { personaId, invokerJid, capabilities } = {}) {
+    if (!personaId && !invokerJid && !capabilities) return message;
+    const botMetadata = {};
+    if (personaId) botMetadata.personaId = personaId;
+    if (invokerJid) botMetadata.invokerJid = invokerJid;
+    if (capabilities?.length) botMetadata.capabilityMetadata = { capabilities };
+    return {
+        ...message,
+        messageContextInfo: { ...(message.messageContextInfo ?? {}), botMetadata }
+    };
+}
+
+export function attachBotThread(message, { remoteJid, aiThreadId, threadType }) {
+    const ctx = message.messageContextInfo ?? {};
+    const type = threadType ?? proto.AIThreadInfo.AIThreadClientInfo.AIThreadType.DEFAULT;
+    return {
+        ...message,
+        messageContextInfo: {
+            ...ctx,
+            threadId: [
+                {
+                    threadType: proto.ThreadID.ThreadType.AI_THREAD,
+                    threadKey: { remoteJid, fromMe: true, id: aiThreadId }
+                }
+            ],
+            botMetadata: { ...(ctx.botMetadata ?? {}), botThreadInfo: { clientInfo: { type } } }
+        }
+    };
+}
+
+/** JID bot yang di-mention di dalam botInvokeMessage, atau null. */
+export function extractInvokedBotJid(message) {
+    const inner = message.botInvokeMessage?.message;
+    if (!inner) return null;
+    const mentioned = inner.extendedTextMessage?.contextInfo?.mentionedJid ??
+        inner.imageMessage?.contextInfo?.mentionedJid ??
+        inner.videoMessage?.contextInfo?.mentionedJid ??
+        inner.documentMessage?.contextInfo?.mentionedJid;
+    if (!mentioned) return null;
+    return mentioned.find(isBotServerJid) ?? null;
+}
+
+export function buildBotInvokeProtoCopy(message, botMessageSecret) {
+    const { messageContextInfo, ...rest } = message;
+    if (!messageContextInfo && !botMessageSecret) return rest;
+    const next = { ...(messageContextInfo ?? {}), messageSecret: undefined };
+    if (botMessageSecret) next.botMessageSecret = botMessageSecret;
+    return { ...rest, messageContextInfo: next };
+}

package/lib/Utils/native-backend.d.ts

@@ -0,0 +1,3 @@
+export declare const resolveNativeBackend: () => any | null;
+export declare const getNativeCrypto: () => { x25519: ((priv: Uint8Array, pub: Uint8Array) => Uint8Array) | null; xeddsaSign: ((priv: Uint8Array, msg: Uint8Array) => Uint8Array) | null; xeddsaVerify: ((pub: Uint8Array, msg: Uint8Array, sig: Uint8Array) => boolean) | null };
+export declare const isNativeCryptoActive: () => boolean;

package/lib/Utils/native-backend.js

@@ -0,0 +1,56 @@
+// Akselerator kripto native opsional (@zapo-js/native, MIT) - diadaptasi dari zapo-js.
+// Mempercepat X25519 ECDH dan XEdDSA sign/verify. Otomatis dipakai jika paket terpasang,
+// jika tidak ada atau gagal load -> fallback ke implementasi JS (libsignal), tanpa perubahan kode.
+// Env: SAURUS_NATIVE_BACKEND (atau ZAPO_NATIVE_BACKEND) = auto | napi | wasm | js | none
+import { createRequire } from 'module';
+import { readFileSync } from 'fs';
+
+const require = createRequire(import.meta.url);
+const WASM_MODULE = '@zapo-js/native/wasm/pkg/zapo_native_wasm.js';
+const WASM_BINARY = '@zapo-js/native/wasm/pkg/zapo_native_wasm_bg.wasm';
+
+const isAbsence = (error) => {
+    const code = error?.code;
+    const message = String(error?.message ?? '');
+    return (code === 'MODULE_NOT_FOUND' || code === 'ERR_MODULE_NOT_FOUND' || message.includes('Cannot find native binding')) &&
+        (message.includes('@zapo-js/native') || message.includes('zapo_native_wasm') || message.includes('Cannot find native binding'));
+};
+const warn = (backend, error) => process.emitWarning('failed to load native crypto accelerator, falling back to JS', {
+    code: 'SAURUS_NATIVE_LOAD_FAILED',
+    detail: `${backend}: ${error?.message ?? error}`
+});
+
+let cached;
+export const resolveNativeBackend = () => {
+    if (cached !== undefined) return cached;
+    const mode = (process.env.SAURUS_NATIVE_BACKEND ?? process.env.ZAPO_NATIVE_BACKEND ?? 'auto').toLowerCase();
+    cached = null;
+    if (mode === 'js' || mode === 'none') return cached;
+    if (mode === 'napi' || mode === 'auto') {
+        try { cached = require('@zapo-js/native'); }
+        catch (error) { if (!isAbsence(error)) warn('napi', error); }
+    }
+    if (cached === null && (mode === 'wasm' || mode === 'auto')) {
+        try {
+            const mod = require(WASM_MODULE);
+            mod.initSync({ module: readFileSync(require.resolve(WASM_BINARY)) });
+            cached = mod;
+        }
+        catch (error) { if (!isAbsence(error)) warn('wasm', error); }
+    }
+    return cached;
+};
+
+/** Fungsi native yang tersedia (atau null jika memakai JS). */
+export const getNativeCrypto = () => {
+    const mod = resolveNativeBackend();
+    return {
+        x25519: mod && typeof mod.x25519ScalarMult === 'function' ? mod.x25519ScalarMult : null,
+        xeddsaSign: mod && typeof mod.xeddsaSign === 'function' ? mod.xeddsaSign : null,
+        xeddsaVerify: mod && typeof mod.xeddsaVerify === 'function' ? mod.xeddsaVerify : null
+    };
+};
+export const isNativeCryptoActive = () => {
+    const n = getNativeCrypto();
+    return !!(n.x25519 || n.xeddsaSign || n.xeddsaVerify);
+};

package/lib/Utils/plugins.d.ts

@@ -0,0 +1,20 @@
+export interface PluginContext {
+    sock: any; config: any; logger?: any; ev: any;
+    on: (...args: any[]) => void; off: (...args: any[]) => void;
+    registerDispose: (fn: () => void | Promise<void>) => void;
+    extend: (members: Record<string, any>) => void;
+}
+export interface PluginDefinition<T = any> {
+    id: string;
+    exposeAs?: string;
+    setup: (ctx: PluginContext) => T;
+    dispose?: (instance: T, ctx: PluginContext) => void | Promise<void>;
+}
+export declare const definePlugin: <T = any>(input: PluginDefinition<T>) => Readonly<PluginDefinition<T>>;
+export declare const makePluginHost: (sock: any, config?: any) => {
+    use: (plugin: PluginDefinition) => any;
+    removePlugin: (id: string) => Promise<boolean>;
+    hasPlugin: (id: string) => boolean;
+    listPlugins: () => string[];
+    disposeAll: () => Promise<void>;
+};

package/lib/Utils/plugins.js

@@ -0,0 +1,78 @@
+// Plugin system: sock.use(plugin) - terinspirasi defineWaClientPlugin milik zapo-js (MIT).
+// Plugin = { id, exposeAs?, setup(ctx), dispose?(instance, ctx) }.
+//  - exposeAs: hasil setup() dipasang di sock[exposeAs]
+//  - ctx.extend({ nama: nilai }): tambah banyak member ke sock (otomatis dicabut saat dispose)
+export const definePlugin = (input) => {
+    if (!input || typeof input.id !== 'string' || !input.id) {
+        throw new Error('plugin requires a non-empty string id');
+    }
+    if (typeof input.setup !== 'function') {
+        throw new Error(`plugin ${input.id} requires a setup function`);
+    }
+    return Object.freeze({ id: input.id, exposeAs: input.exposeAs, setup: input.setup, dispose: input.dispose });
+};
+
+export const makePluginHost = (sock, config = {}) => {
+    const installed = new Map(); // id -> { plugin, instance, ctx, disposers, members }
+    const disabled = new Set(config.disablePlugins ?? []);
+    const define = (name, descriptor) => {
+        Object.defineProperty(sock, name, { configurable: true, enumerable: true, ...descriptor });
+    };
+    const use = (input) => {
+        const plugin = definePlugin(input);
+        if (disabled.has(plugin.id)) {
+            return sock;
+        }
+        if (installed.has(plugin.id)) {
+            throw new Error(`duplicate plugin id: ${plugin.id}`);
+        }
+        const members = [];
+        const disposers = [];
+        const claim = (name) => {
+            if (name in sock) {
+                throw new Error(`plugin ${plugin.id}: member "${name}" collides with an existing socket member`);
+            }
+            members.push(name);
+        };
+        const ctx = {
+            sock,
+            config,
+            logger: config.logger?.child ? config.logger.child({ plugin: plugin.id }) : config.logger,
+            ev: sock.ev,
+            on: (...a) => sock.ev.on(...a),
+            off: (...a) => sock.ev.off(...a),
+            registerDispose: (fn) => disposers.push(fn),
+            extend: (obj) => {
+                for (const [name, value] of Object.entries(obj)) {
+                    claim(name);
+                    define(name, { value, writable: true });
+                }
+            }
+        };
+        const instance = plugin.setup(ctx);
+        if (plugin.exposeAs) {
+            claim(plugin.exposeAs);
+            define(plugin.exposeAs, { value: instance, writable: true });
+        }
+        installed.set(plugin.id, { plugin, instance, ctx, disposers, members });
+        return sock;
+    };
+    const remove = async (id) => {
+        const entry = installed.get(id);
+        if (!entry) return false;
+        installed.delete(id);
+        for (let i = entry.disposers.length - 1; i >= 0; i--) {
+            try { await entry.disposers[i](); } catch { /* abaikan */ }
+        }
+        try { await entry.plugin.dispose?.(entry.instance, entry.ctx); } catch { /* abaikan */ }
+        for (const name of entry.members) delete sock[name];
+        return true;
+    };
+    return {
+        use,
+        removePlugin: remove,
+        hasPlugin: (id) => installed.has(id),
+        listPlugins: () => [...installed.keys()],
+        disposeAll: async () => { for (const id of [...installed.keys()].reverse()) await remove(id); }
+    };
+};

package/lib/Utils/presence-profile.d.ts

@@ -0,0 +1,18 @@
+export interface PresenceApi {
+    setOnline(): Promise<void>; setOffline(): Promise<void>;
+    typing(jid: string): Promise<void>; recording(jid: string): Promise<void>; paused(jid: string): Promise<void>;
+    subscribe(jid: string): Promise<void>;
+    typeFor(jid: string, ms?: number): Promise<void>;
+    withTyping<T>(jid: string, fn: () => Promise<T> | T, kind?: 'composing' | 'recording'): Promise<T>;
+}
+export interface ProfileApi {
+    getPicture(jid: string, type?: 'preview' | 'image', timeoutMs?: number): Promise<string | undefined>;
+    setPicture(jid: string, content: any, dimensions?: { width: number; height: number }): Promise<void>;
+    removePicture(jid: string): Promise<void>;
+    getStatus(...jids: string[]): Promise<any>;
+    setStatus(text: string): Promise<void>;
+    setName(name: string): Promise<void>;
+    username: { get(): Promise<any>; set(username: string, options?: any): Promise<any>; delete(): Promise<any>; check(username: string): Promise<any>; recommendations(source?: string): Promise<any>; setPin(pin: string): Promise<any>; find(username: string, pin?: string): Promise<any> };
+}
+export declare const makePresence: (sock: any) => PresenceApi;
+export declare const makeProfile: (sock: any) => ProfileApi;

package/lib/Utils/presence-profile.js

@@ -0,0 +1,50 @@
+// Presence & Profile coordinator - API rapi di atas fungsi socket yang sudah ada.
+// Terinspirasi client.presence / client.profile milik zapo-js (MIT).
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export const makePresence = (sock) => {
+    const send = (type, jid) => sock.sendPresenceUpdate(type, jid);
+    return {
+        setOnline: () => send('available'),
+        setOffline: () => send('unavailable'),
+        typing: (jid) => send('composing', jid),
+        recording: (jid) => send('recording', jid),
+        paused: (jid) => send('paused', jid),
+        subscribe: (jid) => sock.presenceSubscribe(jid),
+        /** composing -> tunggu ms -> paused */
+        async typeFor(jid, ms = 1000) {
+            await send('composing', jid);
+            await sleep(ms);
+            await send('paused', jid);
+        },
+        /** Tampilkan "mengetik" selama fn berjalan, lalu paused (tetap paused walau fn error). */
+        async withTyping(jid, fn, kind = 'composing') {
+            await send(kind, jid);
+            try {
+                return await fn();
+            }
+            finally {
+                await send('paused', jid).catch(() => { });
+            }
+        }
+    };
+};
+
+export const makeProfile = (sock) => ({
+    getPicture: (jid, type = 'preview', timeoutMs) => sock.profilePictureUrl(jid, type, timeoutMs),
+    setPicture: (jid, content, dimensions) => sock.updateProfilePicture(jid, content, dimensions),
+    removePicture: (jid) => sock.removeProfilePicture(jid),
+    getStatus: (...jids) => sock.fetchStatus(...jids),
+    setStatus: (text) => sock.updateProfileStatus(text),
+    setName: (name) => sock.updateProfileName(name),
+    /** Username (jika modul username tersedia di socket) */
+    username: {
+        get: () => sock.getMyUsername?.(),
+        set: (username, options) => sock.setUsername(username, options),
+        delete: () => sock.deleteUsername(),
+        check: (username) => sock.checkUsername(username),
+        recommendations: (source) => sock.getUsernameRecommendations(source),
+        setPin: (pin) => sock.setUsernamePin(pin),
+        find: (username, pin) => sock.findUserByUsername?.(username, pin)
+    }
+});

package/lib/index.js

@@ -1,5 +1,10 @@
 import makeWASocket from './Socket/index.js';
 import chalk from "chalk";
+import { createRequire } from "module";
+
+const require = createRequire(import.meta.url);
+// Versi diambil dari package.json supaya selalu sinkron.
+export const packageVersion = require("../package.json").version;
 
 const ascii = [
     "⠀⠀⠀⠀⢀⡠⠤⠔⢲⢶⡖⠒⠤⢄⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀",
@@ -22,13 +27,16 @@ const ascii = [
 const info = [
     { label: "", value: "Baileys Saurus Pro", title: true },
     { label: "", value: "" },
-    { label: "✦", value: "Custom Baileys Socket" },
-    { label: "✦", value: "Custom Pairing Support" },
-    { label: "✦", value: "Rich Message Support" },
+    { label: "✦", value: "Pairing Code & QR (kode acak, sudah diperbaiki)" },
+    { label: "✦", value: "Rich Message (AIRich, Carousel, Button)" },
     { label: "✦", value: "SPR (Selective Relay)" },
     { label: "✦", value: "Newsletter Status" },
+    { label: "✦", value: "Greeting Card /buss" },
+    { label: "✦", value: "Plugin System (sock.use)" },
+    { label: "✦", value: "Presence & Profile API" },
+    { label: "✦", value: "Native Crypto (opsional)" },
     { label: "", value: "" },
-    { label: "Version", value: "v5.0.1" },
+    { label: "Version", value: `v${packageVersion}` },
     { label: "Owner", value: "Saurus / Dinonic" },
     { label: "Telegram", value: "t.me/lordsaurus" },
     { label: "WA Owner", value: "+62 895-6390-43495" }
@@ -45,6 +53,7 @@ const infoLines = info.map(({ label, value, title }) => {
 });
 
 const rows = Math.max(ascii.length, infoLines.length);
+if (!process.env.SAURUS_NO_BANNER) {
 console.log("\n");
 for (let i = 0; i < rows; i++) {
     const art = ascii[i] || "".padEnd(24);
@@ -52,6 +61,7 @@ for (let i = 0; i < rows; i++) {
     console.log("  " + purple(art) + "   " + text);
 }
 console.log("\n");
+}
 export * from '../WAProto/index.js';
 export * from './Utils/index.js';
 export * from './Types/index.js';

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "sauruspro-bail",
-    "version": "5.0.2-alpha.spr.test",
-    "description": "Sauruspro Baileys - Custom WhatsApp Web API with SPR (Selective Relay), Newsletter Status, Rich Messages and pairing support.",
+    "version": "5.0.3",
+    "description": "Sauruspro Baileys - WhatsApp Web API (Baileys) dengan SPR (Selective Relay), Newsletter Status, Rich Messages, Greeting Card, plugin system, dan pairing code.",
     "keywords": [
         "baileys",
         "whatsapp",
@@ -96,7 +96,8 @@
         "audio-decode": "^2.1.3",
         "jimp": "^1.6.1",
         "link-preview-js": "^3.0.0",
-        "sharp": "*"
+        "sharp": "*",
+        "@zapo-js/native": "*"
     },
     "resolutions": {
         "ajv@npm:^6.12.4": "^6.14.0",
@@ -136,6 +137,9 @@
         },
         "link-preview-js": {
             "optional": true
+        },
+        "@zapo-js/native": {
+            "optional": true
         }
     },
     "packageManager": "yarn@4.9.2",