kersiosocket 0.5.0-dev → 0.6.0-dev

package/test/backend-adapters.test.js

@@ -0,0 +1,59 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { EventEmitter } = require('node:events')
+const { ZapoBackend } = require('../src/backends/zapo')
+const { BaileysBackend } = require('../src/backends/baileys')
+
+class FakeZapo extends EventEmitter {
+  constructor() { super(); this.sent = []; this.message = { send: async (...args) => { this.sent.push(args); return { ok: true } } }; this.connected = 0 }
+  async connect() { this.connected++; this.emit('connection.update', { connection: 'open' }) }
+  async disconnect() { this.closed = true }
+}
+
+class FakeBaileysSocket {
+  constructor() { this.ev = new EventEmitter(); this.sent = []; this.pairCalls = []; this.ended = false }
+  async sendMessage(...args) { this.sent.push(args); return { key: { id: 'm1' } } }
+  async requestPairingCode(phone) { this.pairCalls.push(phone); return 'ABCD-1234' }
+  async end() { this.ended = true }
+}
+
+test('Zapo adapter forwards auth/message events and calls public message.send', async () => {
+  const raw = new FakeZapo()
+  const backend = new ZapoBackend(raw, { sessionId: 'test' })
+  const messages = []
+  const qr = []
+  backend.on('messages.upsert', (x) => messages.push(x))
+  backend.on('pairing.qr', (x) => qr.push(x.qr))
+  raw.emit('auth_qr', { qr: 'test-qr' })
+  const msg = { key: { remoteJid: '1@s.whatsapp.net', id: 'm1' }, message: { conversation: 'hi' } }
+  raw.emit('message', msg)
+  assert.deepEqual(qr, ['test-qr'])
+  assert.equal(messages[0].messages[0], msg)
+  await backend.connect()
+  await backend.sendMessage('1@s.whatsapp.net', 'pong')
+  assert.deepEqual(raw.sent[0], ['1@s.whatsapp.net', 'pong'])
+  await backend.close()
+  assert.equal(raw.closed, true)
+})
+
+test('Baileys adapter forwards connection/messages and maps common methods', async () => {
+  const socket = new FakeBaileysSocket()
+  const mod = { downloadMediaMessage: async () => Buffer.from('media') }
+  const backend = new BaileysBackend(socket, { baileysModule: mod })
+  const updates = []
+  const incoming = []
+  backend.on('pairing.qr', (p) => updates.push(p.qr))
+  backend.on('message', (m) => incoming.push(m))
+  socket.ev.emit('connection.update', { qr: 'q1' })
+  const msg = { key: { id: 'm1', remoteJid: '1@s.whatsapp.net' }, message: { conversation: 'hello' } }
+  socket.ev.emit('messages.upsert', { type: 'notify', messages: [msg] })
+  await backend.sendMessage('1@s.whatsapp.net', 'pong')
+  assert.deepEqual(updates, ['q1'])
+  assert.deepEqual(incoming, [msg])
+  assert.deepEqual(socket.sent[0][1], { text: 'pong' })
+  assert.equal(await backend.requestPairingCode('628123456789'), 'ABCD-1234')
+  assert.deepEqual(await backend.downloadMedia(msg), Buffer.from('media'))
+  await backend.close()
+  assert.equal(socket.ended, true)
+})

package/test/connection.test.js

@@ -50,7 +50,7 @@ test('koneksi penuh: handshake, terima & kirim frame, stats, end()', async () =>
   })
 
   const sock = makeSocket({
-    transportFactory: srv, clientPayload: Buffer.from('cp'), reconnect: { enabled: false }
+    transportFactory: srv, clientPayload: Buffer.from('cp'), strictServerCertificateVerification: false, reconnect: { enabled: false }
   })
   const states = []
   sock.ev.on('connection.update', (u) => states.push(u.connection))
@@ -83,7 +83,7 @@ test('listener frame yang melempar error TIDAK memutus koneksi; latensi tercatat
       setTimeout(() => d.t.emit('message', encodeFrame(d.hs.noise.encrypt(Buffer.from('dua')))), 10)
     }
   })
-  const sock = makeSocket({ transportFactory: srv, reconnect: { enabled: false } })
+  const sock = makeSocket({ transportFactory: srv, strictServerCertificateVerification: false, reconnect: { enabled: false } })
   const handlerErrors = []
   const frames = []
   const observerFrames = []
@@ -106,7 +106,7 @@ test('frame rusak (gagal dekripsi) tetap menutup koneksi sebagai error protokol'
   const srv = fakeServer((type, d) => {
     if (type === 'server-ready') d.t.emit('message', encodeFrame(Buffer.alloc(40, 1)))
   })
-  const sock = makeSocket({ transportFactory: srv, reconnect: { enabled: false } })
+  const sock = makeSocket({ transportFactory: srv, strictServerCertificateVerification: false, reconnect: { enabled: false } })
   const errs = []
   sock.ev.on('connection.error', (e) => errs.push(e))
   await new Promise((resolve, reject) => {
@@ -122,7 +122,7 @@ test('backoff TIDAK direset bila server menutup tepat setelah handshake', async
   const log = { debug() {}, info(m) { const x = /dalam (\d+)ms/.exec(m); if (x) delays.push(+x[1]) }, warn() {}, error() {} }
   const srv = fakeServer((type, d) => { if (type === 'server-ready') setImmediate(() => d.t.emit('close', 1006, '')) })
   const sock = makeSocket({
-    transportFactory: srv, logger: log,
+    transportFactory: srv, logger: log, strictServerCertificateVerification: false,
     reconnect: { minDelay: 10, maxDelay: 1000, factor: 2, stableMs: 30000 }
   })
   await new Promise((r) => setTimeout(r, 400))
@@ -145,9 +145,29 @@ test('ClientPayload terstruktur di-encode sebelum dikirim dalam ClientFinish', a
         if (type === 'server-ready') resolve(d.payload)
       }),
       clientPayload: options,
+      strictServerCertificateVerification: false,
       reconnect: { enabled: false }
     })
     sock.ev.on('connection.error', (e) => { throw e })
   })
   assert.deepEqual(await received, expected)
 })
+
+test('native connection fails closed by default without Noise certificate verifier', async () => {
+  const srv = fakeServer(() => {})
+  const sock = makeSocket({ transportFactory: srv, reconnect: { enabled: true, minDelay: 10, maxDelay: 20, factor: 2, stableMs: 1000 } })
+  const errors = []
+  sock.ev.on('connection.error', (error) => errors.push(error))
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('timeout waiting for strict-certificate close')), 1000)
+    sock.ev.on('connection.update', (update) => {
+      if (update.connection === 'close') { clearTimeout(timer); resolve() }
+    })
+  })
+  await new Promise((resolve) => setTimeout(resolve, 60))
+  assert.equal(errors.length, 1)
+  assert.equal(errors[0].code, 'ERR_NOISE_CERTIFICATE_VERIFIER_MISSING')
+  assert.equal(sock.state, 'close')
+  assert.equal(sock.stats().serverCertificateVerified, false)
+  sock.end()
+})

package/test/locking-archive.test.js

@@ -0,0 +1,49 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs/promises')
+const os = require('node:os')
+const path = require('node:path')
+const { MemoryStore } = require('../src/session/stores')
+const { KeyedMutex, FileLockManager, MessageArchive } = require('../src/session/locking')
+
+test('KeyedMutex membuat operasi dengan key sama berjalan serial', async () => {
+  const mutex = new KeyedMutex()
+  const sequence = []
+  await Promise.all([
+    mutex.run('a', async () => { sequence.push('a1-start'); await new Promise((r) => setTimeout(r, 20)); sequence.push('a1-end') }),
+    mutex.run('a', async () => { sequence.push('a2-start'); sequence.push('a2-end') }),
+    mutex.run('b', async () => { sequence.push('b-start'); sequence.push('b-end') })
+  ])
+  assert.ok(sequence.indexOf('a1-end') < sequence.indexOf('a2-start'))
+})
+
+test('FileLockManager mencegah dua operasi concurrent dan melepaskan lock saat error', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'kersio-lock-'))
+  try {
+    const a = new FileLockManager(dir, { staleMs: 5000, heartbeatMs: 500, retryMs: 5 })
+    const b = new FileLockManager(dir, { staleMs: 5000, heartbeatMs: 500, retryMs: 5 })
+    let active = 0, maxActive = 0
+    await Promise.all([
+      a.withLock('session-a', async () => { active++; maxActive = Math.max(maxActive, active); await new Promise((r) => setTimeout(r, 35)); active-- }),
+      b.withLock('session-a', async () => { active++; maxActive = Math.max(maxActive, active); await new Promise((r) => setTimeout(r, 10)); active-- })
+    ])
+    assert.equal(maxActive, 1)
+    await assert.rejects(() => a.withLock('throws', async () => { throw new Error('expected') }), /expected/)
+    assert.equal((await fs.readdir(dir)).filter((x) => x.endsWith('.lock')).length, 0)
+  } finally { await fs.rm(dir, { recursive: true, force: true }) }
+})
+
+test('MessageArchive writes bounded history and exposes getMessage()', async () => {
+  const store = new MemoryStore()
+  const archive = new MessageArchive(store, { sessionId: 'archive-test', maxMessagesPerChat: 2 })
+  const mk = (id, text) => ({ key: { id, remoteJid: '1@s.whatsapp.net' }, message: { conversation: text } })
+  await archive.put(mk('1', 'one'))
+  await archive.put(mk('2', 'two'))
+  await archive.put(mk('3', 'three'))
+  assert.equal(await archive.getMessage({ id: '3', remoteJid: '1@s.whatsapp.net' }).then((v) => v.conversation), 'three')
+  assert.equal(await archive.getRecord({ id: '1', remoteJid: '1@s.whatsapp.net' }), undefined)
+  assert.deepEqual((await archive.recent('1@s.whatsapp.net', 10)).map((m) => m.key.id), ['3', '2'])
+  await archive.delete({ id: '2', remoteJid: '1@s.whatsapp.net' })
+  assert.deepEqual((await archive.recent('1@s.whatsapp.net')).map((m) => m.key.id), ['3'])
+})

package/test/noise.test.js

@@ -64,3 +64,25 @@ test('Noise: ServerHello dengan hash berbeda (header beda) gagal', () => {
   const sh = server.processClientHello(client.hello())
   assert.throws(() => client.processServerHello(sh, Buffer.alloc(0)))
 })
+
+test('Noise strict mode menolak server certificate bila verifier tidak dikonfigurasi', () => {
+  const server = new ServerHandshake({ certificate: Buffer.from('untrusted') })
+  const client = new ClientHandshake({ staticKey: generateKeyPair(), requireServerCertificateVerification: true })
+  const serverHello = server.processClientHello(client.hello())
+  assert.throws(() => client.processServerHello(serverHello, Buffer.alloc(0)), /verifier sertifikat server belum dikonfigurasi/)
+  assert.equal(client.serverCertificateVerified, false)
+})
+
+test('Noise strict mode hanya menerima certificate bila verifier menyatakan true', () => {
+  const expected = Buffer.from('pinned-test-certificate')
+  const server = new ServerHandshake({ certificate: expected })
+  const client = new ClientHandshake({
+    staticKey: generateKeyPair(),
+    requireServerCertificateVerification: true,
+    verifyServerCertificate: (certificate) => certificate.equals(expected)
+  })
+  const serverHello = server.processClientHello(client.hello())
+  const finish = client.processServerHello(serverHello, Buffer.alloc(0))
+  server.processClientFinish(finish)
+  assert.equal(client.serverCertificateVerified, true)
+})

package/test/session-manager.test.js

@@ -0,0 +1,34 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { EventEmitter } = require('node:events')
+const { KersioSessionManager } = require('../src/client/session-manager')
+const { KersioClient } = require('../src/client/kersio-client')
+
+class StubBackend extends EventEmitter {
+  constructor(engine) { super(); this.engine = engine; this.closed = false }
+  async connect() { this.emit('connection.update', { connection: 'open' }) }
+  async sendMessage(jid, content) { return { jid, content } }
+  async close() { this.closed = true }
+  capabilities() { return { engine: this.engine, live: false, messaging: true } }
+}
+
+test('session manager keeps independent sessions on different engines and closes them', async () => {
+  const made = []
+  const manager = new KersioSessionManager({ clientFactory: async ({ engine, sessionId }) => {
+    const backend = new StubBackend(engine)
+    made.push(backend)
+    return new KersioClient(backend, { sessionId })
+  } })
+  const zapo = await manager.open('acc-a', { engine: 'zapo' })
+  const baileys = await manager.open('acc-b', { engine: 'baileys' })
+  assert.equal(zapo.engine, 'zapo')
+  assert.equal(baileys.engine, 'baileys')
+  assert.equal(manager.stats().open, 2)
+  assert.equal(manager.get('acc-a'), zapo)
+  await assert.rejects(() => manager.open('acc-a', { engine: 'zapo' }), /sudah dibuka/)
+  assert.equal(await manager.close('acc-a'), true)
+  await manager.closeAll()
+  assert.equal(made.every((backend) => backend.closed), true)
+  assert.equal(manager.stats().total, 0)
+})

package/test/unified-client.test.js

@@ -0,0 +1,63 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { EventEmitter } = require('node:events')
+const { createKersioClient, KersioClient } = require('../src/client/kersio-client')
+const { BackendNotSupportedError } = require('../src/backends/base')
+
+class FakeBackend extends EventEmitter {
+  constructor() { super(); this.engine = 'fake'; this.sent = []; this.connected = false; this.closed = false }
+  async connect() { this.connected = true; this.emit('connection.update', { connection: 'open' }) }
+  async sendMessage(jid, content, options) { this.sent.push({ jid, content, options }); return { key: { id: `m${this.sent.length}` } } }
+  async close() { this.closed = true }
+  capabilities() { return { engine: this.engine, live: true, messaging: true, media: true, groups: false, historySync: false } }
+}
+
+test('unified client normalizes text/media/reaction API and validates user input', async () => {
+  const backend = new FakeBackend()
+  const client = new KersioClient(backend)
+  await client.connect()
+  await client.sendText('123@s.whatsapp.net', 'halo')
+  await client.sendImage('123@s.whatsapp.net', Buffer.from('image'), { caption: 'foto' })
+  await client.react('123@s.whatsapp.net', { id: 'old', remoteJid: '123@s.whatsapp.net' }, '👍')
+  assert.deepEqual(backend.sent[0].content, { text: 'halo' })
+  assert.equal(backend.sent[1].content.caption, 'foto')
+  assert.equal(backend.sent[2].content.react.text, '👍')
+  await assert.rejects(() => client.sendText('', 'x'), /jid/)
+  await assert.rejects(() => client.sendImage('123@s.whatsapp.net', null), /wajib diisi/)
+  await client.close()
+  assert.equal(backend.closed, true)
+})
+
+test('connect() tidak menganggap koneksi berhasil hanya dari Promise resolve', async () => {
+  class NotReadyBackend extends FakeBackend { async connect() {} }
+  const client = new KersioClient(new NotReadyBackend())
+  await client.connect()
+  assert.equal(client.state, 'connecting')
+  await assert.rejects(() => client.sendText('123@s.whatsapp.net', 'belum siap'), /belum open/)
+  await client.close()
+})
+
+test('backend QR event yang sudah terjadi direplay ketika facade terpasang', async () => {
+  class ReplayBackend extends FakeBackend {
+    constructor() { super(); this.last = new Map([['pairing.qr', { qr: 'candidate' }]]) }
+    replay(event, handler) { if (this.last.has(event)) handler(this.last.get(event)) }
+  }
+  const client = new KersioClient(new ReplayBackend())
+  const qr = []
+  client.on('pairing.qr', (v) => qr.push(v.qr))
+  await new Promise((resolve) => setImmediate(resolve))
+  assert.deepEqual(qr, ['candidate'])
+  await client.close()
+})
+
+test('factory menolak native sebagai message engine yang belum lengkap', async () => {
+  await assert.rejects(() => createKersioClient({ engine: 'native' }), /belum complete/)
+})
+
+test('feature yang tidak didukung menghasilkan error eksplisit, tidak mengembalikan sukses palsu', async () => {
+  const client = await createKersioClient({ backend: new FakeBackend() })
+  await client.connect()
+  await assert.rejects(() => client.downloadMedia({}), BackendNotSupportedError)
+  await client.close()
+})

package/test/verified-commit.test.js

@@ -0,0 +1,43 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { MemoryStore } = require('../src/session/stores')
+const { PairingLifecycle } = require('../src/pairing/lifecycle')
+const { commitVerifiedPairSuccess } = require('../src/pairing/verified-commit')
+
+test('pair success tidak dipersistenkan atau ditandai paired bila pemeriksaan gagal', async () => {
+  const store = new MemoryStore()
+  const lifecycle = new PairingLifecycle({ sessionId: 'secure-test' })
+  lifecycle.begin('qr')
+  await assert.rejects(() => commitVerifiedPairSuccess({
+    node: { tag: 'iq' },
+    verifyPairSuccess: async () => ({ verified: true, checks: { deviceIdentity: true, accountSignature: true, advHmac: false }, credentials: { me: 'x' }, replyNode: { tag: 'iq' } }),
+    store, lifecycle, sendNode: async () => {}
+  }), { code: 'ERR_PAIR_SUCCESS_UNVERIFIED' })
+  assert.equal(lifecycle.state, 'waiting-qr')
+  assert.equal(await store.get('auth:secure-test:credentials'), undefined)
+})
+
+test('pair success commit membutuhkan semua check + credentials, menyimpan lalu membalas sebelum paired', async () => {
+  const store = new MemoryStore()
+  const lifecycle = new PairingLifecycle({ sessionId: 'secure-test' })
+  lifecycle.begin('qr')
+  const steps = []
+  const result = await commitVerifiedPairSuccess({
+    node: { tag: 'iq' },
+    verifyPairSuccess: async () => ({
+      verified: true,
+      checks: { deviceIdentity: true, accountSignature: true, advHmac: true },
+      credentials: { me: '123@s.whatsapp.net' },
+      replyNode: { tag: 'iq', attrs: { type: 'set' }, content: [{ tag: 'pair-device-sign', attrs: {} }] }
+    }),
+    store: { set: async (key, value) => { steps.push('store'); return store.set(key, value) } },
+    lifecycle,
+    sendNode: async (node) => { steps.push('reply'); assert.equal(node.content[0].tag, 'pair-device-sign') }
+  })
+  steps.push('after')
+  assert.deepEqual(steps, ['store', 'reply', 'after'])
+  assert.equal(result.verified, true)
+  assert.equal(lifecycle.state, 'paired')
+  assert.deepEqual(await store.get('auth:secure-test:credentials'), { me: '123@s.whatsapp.net' })
+})

package/test/whatsmeow-process.test.js

@@ -0,0 +1,43 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { WhatsmeowProcessBackend, jsonSafe } = require('../src/backends/whatsmeow-process')
+
+const fakeBridge = String.raw`
+const readline = require('node:readline');
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on('line', (line) => {
+  let x; try { x = JSON.parse(line) } catch { process.exit(9) }
+  if (x.method === 'close') { process.stdout.write(JSON.stringify({ id:x.id, result:{closed:true} })+'\n'); setImmediate(() => process.exit(0)); return; }
+  if (x.method === 'connect') { process.stdout.write(JSON.stringify({ id:x.id, result:{connected:true} })+'\n'); process.stdout.write(JSON.stringify({ event:'messages.upsert', data:{type:'notify', messages:[{key:{id:'in1',remoteJid:'1@s.whatsapp.net'},message:{conversation:'hi'}}]} })+'\n'); return; }
+  if (x.method === 'sendMessage') { process.stdout.write(JSON.stringify({ id:x.id, result:{key:{id:'out1'}, accepted:true, params:x.params} })+'\n'); return; }
+  if (x.method === 'capabilities') { process.stdout.write(JSON.stringify({id:x.id,result:{messaging:true,media:true,groups:true}})+'\n'); return; }
+  process.stdout.write(JSON.stringify({id:x.id,error:{code:'NO_METHOD',message:'unknown method '+x.method}})+'\n');
+});
+`
+
+test('Go process adapter uses JSONL RPC, forwards events, and handles errors', async () => {
+  const bridge = new WhatsmeowProcessBackend({ command: process.execPath, args: ['-e', fakeBridge], sessionId: 'test' })
+  const msgs = []
+  let gotMessageResolve
+  const gotMessage = new Promise((resolve) => { gotMessageResolve = resolve })
+  bridge.on('messages.upsert', (event) => { msgs.push(event); gotMessageResolve() })
+  const cleanup = () => bridge.close().catch(() => {})
+  try {
+    await bridge.connect()
+    await Promise.race([gotMessage, new Promise((_, reject) => setTimeout(() => reject(new Error('timeout waiting for mock event')), 1000))])
+    assert.equal(msgs.length, 1)
+  const sent = await bridge.sendMessage('1@s.whatsapp.net', { text: 'hello' })
+  assert.equal(sent.accepted, true)
+  const caps = await bridge.capabilities()
+  assert.equal(caps.groups, true)
+  await assert.rejects(() => bridge.invoke('nonexistent'), /unknown method/)
+  } finally { await cleanup() }
+})
+
+test('bridge JSON serialisation marks binary as base64 and rejects cycles/functions', () => {
+  assert.deepEqual(jsonSafe(Buffer.from('abc')), { $base64: 'YWJj' })
+  const cycle = {}; cycle.self = cycle
+  assert.throws(() => jsonSafe(cycle), /siklik/)
+  assert.throws(() => jsonSafe(() => {}), /tidak dapat dikirim/)
+})