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

package/README.md

@@ -11,7 +11,7 @@
 ![node](https://img.shields.io/badge/Node.js-20%2B-22c55e?style=for-the-badge)
 ![license](https://img.shields.io/badge/License-MIT-3b82f6?style=for-the-badge)
 
-**Owner: Saurus / Dinonic** · **Version: 5.0.1**
+**Owner: Saurus / Dinonic** · **Version: 5.0.2-alpha.spr.test**
 
 </div>
 
@@ -22,7 +22,7 @@
 | | |
 |---|---|
 | Package | `sauruspro-bail` |
-| Version | `5.0.1` |
+| Version | `5.0.2-alpha.spr.test` |
 | Owner | Saurus / Dinonic |
 | Module type | ESM (`"type": "module"`) |
 | Runtime | Node.js >= 20 |
@@ -100,9 +100,13 @@ Dokumentasi lengkap: **[docs/NEWSLETTER-STATUS.md](docs/NEWSLETTER-STATUS.md)**
 ```js
 await sock.sPR(jid, { conversation: 'Halo!' })
 // alias: sock.relayMessageSelective(jid, message, options)
+
+// pesan privat per orang + foto profil
+await sock.sPRPrivate(groupJid, targetJid, { publicText: 'Ada pesan', privateText: 'rahasia' })
+await sock.sPRBroadcast(groupJid, { template: 'Halo {name}!' })
 ```
 
-Dokumentasi lengkap: **[docs/SPR.md](docs/SPR.md)** · SPR dibuat oleh **Nixel** (watermark di `dinonic-spr.js` tidak boleh dihapus).
+Dokumentasi lengkap: **[docs/SPR.md](docs/SPR.md)**
 
 ## 📚 Dokumentasi
 

package/docs/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 5.0.2-alpha.spr.test
+### Changed
+- `lib/Utils/dinonic-spr.js` ditulis ulang dari nol (engine baru, sender key sekali pakai). API `sPR` / `selectiveRelay` tetap kompatibel.
+
+### Added (diadaptasi dari plugin zapo-js, MIT)
+- Opsi `personal` pada `sPR`: pesan khusus per orang.
+- `sPRPrivate`, `sPRBroadcast` (`{name}` + mention + foto profil), `getSPRTargets`, `loadSPRAvatars`.
+- Batas target 100 + hitung overflow, cache foto, budget/timeout, konkurensi.
+- Reporting token memakai util resmi, tctoken memakai pengecekan expired.
+
 ## 5.0.1
 **Owner: Saurus / Dinonic**
 

package/docs/SPR.md

@@ -1,51 +1,88 @@
-# 🎯 SPR (Selective Relay)
+# 🎯 SPR (Selective & Private Relay)
 
-Kirim pesan dengan kontrol **device/JID mana yang menerima kunci asli**, sisanya menerima kunci palsu sehingga tidak bisa membuka pesan.
+Kirim pesan dengan kontrol **siapa membaca apa**. Tiap device penerima masuk salah satu peran:
 
-> Modul SPR dibuat oleh **Nixel**. Watermark di `lib/Utils/dinonic-spr.js` wajib dipertahankan. Lisensi aslinya melarang reupload/resell sebagai produk mandiri dan mengaku sebagai karya sendiri.
+| Peran | Yang diterima |
+|---|---|
+| `public` | pesan umum (menerima sender key sekali pakai) |
+| `personal` | pesan khusus miliknya (enkripsi 1-lawan-1), tanpa pesan umum |
+| `hidden` | tidak menerima apa-apa |
+
+Sender key dibuat baru untuk setiap pesan dan tidak disimpan, jadi device yang tidak diberi kunci tidak bisa membuka pesan meski pernah menerima pesan lain dari bot.
+
+## API
 
 ```js
-await sock.sPR(jid, message, options)
-// alias
-await sock.relayMessageSelective(jid, message, options)
+await sock.sPR(jid, message, options)          // alias: sock.relayMessageSelective
+await sock.sPRPrivate(groupJid, targetJid, { publicText, privateText })
+await sock.sPRBroadcast(groupJid, { template })
+await sock.getSPRTargets(groupJid, { limit })
 ```
 
-Juga bisa di-import: `import { sPR, selectiveRelay } from 'sauruspro-bail'`
-(`sPR(conn, jid, message, options)`, parameter pertama adalah socket).
+Bisa juga di-import: `import { sPR, sPRPrivate, sPRBroadcast } from 'sauruspro-bail'` (parameter pertama adalah socket).
 
-## Options
+## sPR options
 
 | Option | Default | Keterangan |
 |---|---|---|
-| `mode` | `"exclude"` | `exclude`: target **tidak** menerima. `include`: **hanya** target yang menerima |
-| `target` | `[]` | Daftar JID (PN atau LID) |
+| `mode` | `"exclude"` | `exclude`: target **tidak** menerima pesan publik. `include`: **hanya** target |
+| `target` | `[]` | Daftar JID (PN atau LID, alias dicocokkan otomatis) |
+| `personal` | - | Pesan khusus per orang: `{ jid: message }`, `Map`, atau `({jid,user}) => message` |
 | `targetMe` | - | `true/false` memaksa device milik sendiri menerima/tidak |
-| `deviceMode` | `"all"` | `all` / `primary` (device 0) / `secondary` (device lain) |
+| `deviceMode` | `"all"` | `all` / `primary` (device 0) / `secondary` |
 | `hideDecryptFail` | `true` | Sembunyikan placeholder gagal-dekripsi |
 | `messageId` | auto | ID pesan kustom |
 | `additionalAttributes` / `additionalNodes` | - | Atribut/node tambahan pada stanza |
 | `useUserDevicesCache` / `useCachedGroupMetadata` | - | Pakai cache |
 | `statusJidList` | - | Untuk status broadcast |
 
+`message` boleh `null` bila semua penerima punya pesan `personal`.
+
 ## Contoh
 
 ```js
-// Kirim ke grup, tapi sembunyikan dari 1 orang
+// Sembunyikan dari 1 orang
 await sock.sPR(groupJid, { conversation: 'rahasia' }, {
-  mode: 'exclude',
-  target: ['6281234567890@s.whatsapp.net']
+  mode: 'exclude', target: ['6281234567890@s.whatsapp.net']
+})
+
+// Pesan umum untuk semua, pesan lain khusus untuk A
+await sock.sPR(groupJid, { conversation: 'info umum' }, {
+  personal: { '6281234567890@s.whatsapp.net': { conversation: 'info khusus kamu' } }
+})
+```
+
+## sPRPrivate (setara `!spr publik | privat`)
+
+Anggota lain melihat `publicText`, `targetJid` melihat `privateText` dengan foto profilnya sendiri.
+
+```js
+await sock.sPRPrivate(groupJid, targetJid, {
+  publicText: 'Pesan ini memiliki isi khusus untuk beberapa penerima.',
+  privateText: 'rahasia buat kamu',
+  avatar: true
 })
+// -> { id, avatar }
+```
 
-// Hanya kirim ke 1 orang di grup
-await sock.sPR(groupJid, { conversation: 'khusus kamu' }, {
-  mode: 'include',
-  target: ['6281234567890@s.whatsapp.net']
+## sPRBroadcast (setara `!sbpr` / `!sbrp`)
+
+Tiap anggota menerima pesan sendiri: `{name}` menjadi @mention orang itu, plus foto profilnya.
+Anggota di luar `limit` (default 100) melihat `publicText`. Bot tidak dihitung, admin didahulukan.
+
+```js
+await sock.sPRBroadcast(groupJid, {
+  template: 'Halo {name}, ada pesan untukmu.',
+  limit: 100,
+  avatar: true
 })
+// -> { id, targets, total, overflow, withAvatar }
 ```
 
-## Perubahan v5.0.0
+Foto profil diambil konkuren (10 sekaligus) dengan budget 10 dtk dan batas keras 14 dtk; gagal/lambat otomatis jatuh ke pesan teks. Hasil di-cache (200 entri).
+
+## Catatan
 
-- `lib/Utils/dinonic-spr.js` diganti dengan port ESM langsung dari SPR referensi. Logika **identik**; yang berubah hanya sintaks modul (CJS → ESM).
-- Termasuk fallback `me.id` / `me.lid` ke `conn.user` (tidak crash saat `authState.creds.me` kosong).
-- `sPR` & `selectiveRelay` diexport dari entry utama.
-- `encodeSignedDeviceIdentity` diimpor dari `validate-connection.js` (sebelumnya salah dari `generics.js` sehingga paket gagal load).
+- Penerima `personal` hanya melihat pesan personalnya; pesan umum tidak dikirim ke mereka.
+- Fitur privat/broadcast diadaptasi dari plugin zapo-js (MIT).
+- Perubahan v5.0.2-alpha.spr.test: engine ditulis ulang (kode baru), tambah `personal`, `sPRPrivate`, `sPRBroadcast`, `getSPRTargets`, `loadSPRAvatars`. API `sPR`/`selectiveRelay` lama tetap kompatibel.

package/lib/Socket/index.js

@@ -5,7 +5,7 @@ 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/dinonic-spr.js'
+import { sPR, sPRPrivate, sPRBroadcast, getSPRTargets } from '../Utils/dinonic-spr.js'
 import * as DinonicBuilder from '../Utils/MessageBuilder.js'
 import {
     makeNewsletterStatusSender,
@@ -39,6 +39,9 @@ const makeWASocket = (config) => {
     // SPR (Selective Relay)
     clientWithBuilder.sPR = (jid, message, options) => sPR(clientWithBuilder, jid, message, options);
     clientWithBuilder.relayMessageSelective = clientWithBuilder.sPR;
+    clientWithBuilder.sPRPrivate = (groupJid, targetJid, options) => sPRPrivate(clientWithBuilder, groupJid, targetJid, options);
+    clientWithBuilder.sPRBroadcast = (groupJid, options) => sPRBroadcast(clientWithBuilder, groupJid, options);
+    clientWithBuilder.getSPRTargets = (groupJid, options) => getSPRTargets(clientWithBuilder, groupJid, options);
 
     // Newsletter Status (Channel Status)
     if (!clientWithBuilder.sendNewsletterStatus) {

package/lib/Utils/dinonic-spr.d.ts

@@ -1,26 +1,73 @@
-export function generateSigningKeyPair(): {
-    privateKey: Buffer;
-    publicKey: Buffer;
-};
-export function getMessageKey(seed: Buffer): {
-    iv: Buffer;
-    cipherKey: Buffer;
-};
-export function deriveReportingTag(message: any, msgId: string, remoteJid: string): Buffer;
-export function encryptGroupMessage(plaintext: Buffer | Uint8Array, chainSeed: Buffer, privateKeyObject: any, keyId: number): Buffer;
-export function createSKDM(keyId: number, iteration: number, chainSeed: Buffer, signingPubKey: Buffer): Buffer;
-export function sPR(conn: any, jid: string, message: any, options?: {
+type Jid = string;
+type PersonalInput =
+    | ((ctx: { jid: Jid; user: string }) => any | null)
+    | Map<Jid, any>
+    | Record<Jid, any>;
+
+export interface SPROptions {
     messageId?: string;
     additionalAttributes?: any;
+    additionalNodes?: any[];
     useUserDevicesCache?: boolean;
     useCachedGroupMetadata?: boolean;
     statusJidList?: string[];
-    additionalNodes?: any[];
     targetMe?: boolean;
+    /** Berlaku untuk pesan publik. */
     mode?: "include" | "exclude";
-    target?: string[];
-    hideDecryptFail?: boolean;
+    target?: Jid[];
     deviceMode?: "all" | "primary" | "secondary";
-}): Promise<string>;
+    hideDecryptFail?: boolean;
+    /** Pesan khusus per orang. Penerima personal tidak menerima pesan publik. */
+    personal?: PersonalInput;
+}
+
+export const SPR_LIMITS: Readonly<{
+    targets: number;
+    concurrency: number;
+    encryptConcurrency: number;
+    avatarBudgetMs: number;
+    avatarHardCapMs: number;
+    avatarFetchMs: number;
+    cacheSize: number;
+}>;
+export const SPR_TEXT: Readonly<Record<string, string>>;
+
+export function createOneShotSenderKey(): {
+    keyId: number;
+    distribution(): Buffer;
+    seal(plaintext: Buffer | Uint8Array): Buffer;
+};
+
+export function sPR(conn: any, jid: Jid, message: any | null, options?: SPROptions): Promise<string>;
 export const selectiveRelay: typeof sPR;
+
+export function getSPRTargets(conn: any, groupJid: Jid, options?: { limit?: number; exclude?: Jid[] }): Promise<{
+    meta: any;
+    targets: any[];
+    total: number;
+    overflow: number;
+}>;
+
+export function loadSPRAvatars(conn: any, people: any[], options?: {
+    concurrency?: number;
+    budgetMs?: number;
+    hardCapMs?: number;
+    fetchMs?: number;
+}): Promise<Map<string, any>>;
+
+export function sPRPrivate(conn: any, groupJid: Jid, targetJid: Jid, options: Omit<SPROptions, "personal"> & {
+    publicText?: string;
+    privateText: string;
+    avatar?: boolean;
+    mentionTarget?: boolean;
+}): Promise<{ id: string; avatar: boolean }>;
+
+export function sPRBroadcast(conn: any, groupJid: Jid, options?: Omit<SPROptions, "personal"> & {
+    template?: string;
+    publicText?: string;
+    limit?: number;
+    exclude?: Jid[];
+    avatar?: boolean;
+}): Promise<{ id: string; targets: number; total: number; overflow: number; withAvatar: number }>;
+
 export default sPR;