kersiosocket 0.0.0-stage → 0.5.0-dev

package/test/proto.test.js

@@ -0,0 +1,64 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { encodeVarint, fieldVarint, fieldBool, fieldString, fieldBytes, fieldFixed32, pack, parseFields } = require('../src/proto/wire')
+const { encodeClientPayload, PLATFORM, CONNECT_REASON } = require('../src/proto/client-payload')
+
+const userAgent = {
+  platform: 'WEB', appVersion: [2, 3000, 1040000000],
+  releaseChannel: 'RELEASE', localeLanguage: 'id', localeCountry: 'ID'
+}
+const webInfo = { version: 'test-version-only', webSubPlatform: 'WEB_BROWSER' }
+const registration = {
+  mode: 'registration', passive: false, pushName: 'Kersio test', userAgent, webInfo,
+  connectReason: 'USER_ACTIVATED', connectType: 'WIFI_UNKNOWN', connectAttemptCount: 0,
+  devicePairingData: {
+    eRegid: Buffer.from([0, 0, 0, 1]), eKeytype: Buffer.from([5]), eIdent: Buffer.alloc(32, 1),
+    eSkeyId: Buffer.from([0, 0, 1]), eSkeyVal: Buffer.alloc(32, 2), eSkeySig: Buffer.alloc(64, 3),
+    buildHash: Buffer.alloc(16, 4), deviceProps: Buffer.from([0x0a, 0x01, 0x78])
+  }
+}
+
+test('protobuf wire: varint, string, bool, bytes, sfixed32 round-trip ke entri wire', () => {
+  const payload = pack([
+    fieldVarint(1, 300), fieldBool(2, false), fieldString(3, 'kersio'),
+    fieldBytes(4, Buffer.from([1, 2, 3])), fieldFixed32(5, -42)
+  ])
+  const f = parseFields(payload)
+  assert.deepEqual(f.map((x) => [x.fieldNumber, x.wireType]), [[1, 0], [2, 0], [3, 2], [4, 2], [5, 5]])
+  assert.equal(f[0].value, 300n)
+  assert.equal(f[1].value, 0n)
+  assert.equal(f[2].value.toString(), 'kersio')
+  assert.deepEqual(f[3].value, Buffer.from([1, 2, 3]))
+  assert.equal(f[4].value.readInt32LE(), -42)
+  assert.deepEqual(encodeVarint(0), Buffer.from([0]))
+})
+
+test('ClientPayload registration: membuat bytes berisi field utama dan DevicePairingRegistrationData', () => {
+  const out = encodeClientPayload(registration)
+  assert.ok(out.length > 100)
+  const fields = parseFields(out)
+  assert.ok(fields.some((f) => f.fieldNumber === 3 && f.wireType === 0 && f.value === 0n))
+  assert.ok(fields.some((f) => f.fieldNumber === 5 && f.wireType === 2))
+  assert.ok(fields.some((f) => f.fieldNumber === 6 && f.wireType === 2))
+  assert.ok(fields.some((f) => f.fieldNumber === 19 && f.wireType === 2))
+  assert.equal(PLATFORM.WEB, 14)
+  assert.equal(CONNECT_REASON.USER_ACTIVATED, 1)
+})
+
+test('ClientPayload login: username harus nomor digit dan tanpa pairing registration data', () => {
+  const out = encodeClientPayload({ mode: 'login', username: '6281234567890', userAgent, webInfo, passive: false })
+  const first = parseFields(out)[0]
+  assert.equal(first.fieldNumber, 1)
+  assert.equal(first.value, 6281234567890n)
+  assert.throws(() => encodeClientPayload({ mode: 'login', username: '+6281234567890', userAgent, webInfo }), /digit nomor/)
+  assert.throws(() => encodeClientPayload({ mode: 'registration', userAgent, webInfo }), /devicePairingData lengkap/)
+})
+
+test('ClientPayload: memvalidasi ukuran kunci dan schema wajib', () => {
+  const bad = structuredClone(registration)
+  bad.devicePairingData.eSkeySig = Buffer.alloc(32)
+  assert.throws(() => encodeClientPayload(bad), /eSkeySig harus 64 byte/)
+  assert.throws(() => encodeClientPayload({ mode: 'login', username: '6281234567890', webInfo }), /userAgent wajib diisi/)
+  assert.throws(() => parseFields(Buffer.from([0x0a, 0x05, 0x01])), /panjang field melebihi buffer/)
+})

package/test/session.test.js

@@ -0,0 +1,134 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const { MemoryStore, FileStore, SQLiteStore, RedisStore, MongoStore, LRUCache, createSessionManager, makeSocket } = require('../src')
+
+const tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), 'kersio-'))
+
+async function contract(store) {
+  assert.equal(await store.get('a:x'), undefined)
+  const v = { buf: Buffer.from([1, 2, 3]), big: 123456789012345678901234567890n, n: 5, s: 'é/:*.', nested: { u: new Uint8Array([9, 8]) } }
+  await store.set('a:x', v)
+  const r = await store.get('a:x')
+  assert.ok(Buffer.isBuffer(r.buf)); assert.deepEqual(r.buf, v.buf)
+  assert.equal(r.big, v.big); assert.equal(r.n, 5); assert.equal(r.s, v.s)
+  assert.deepEqual([...r.nested.u], [9, 8])
+  await store.set('a:x', { n: 6 })
+  assert.equal((await store.get('a:x')).n, 6)
+  await store.set('b:y', 1)
+  assert.deepEqual((await store.keys('a:')).sort(), ['a:x'])
+  assert.deepEqual((await store.keys()).sort(), ['a:x', 'b:y'])
+  await store.delete('a:x')
+  assert.equal(await store.get('a:x'), undefined)
+}
+
+test('kontrak store: memory', () => contract(new MemoryStore()))
+test('kontrak store: file', () => contract(new FileStore(tmp())))
+test('kontrak store: sqlite', async () => { const s = new SQLiteStore(':memory:'); await contract(s); await s.close() })
+
+test('kontrak store: redis (klien palsu)', async () => {
+  const m = new Map()
+  const c = { get: async (k) => m.get(k) ?? null, set: async (k, v) => void m.set(k, v), del: async (k) => void m.delete(k),
+    keys: async (p) => [...m.keys()].filter((k) => k.startsWith(p.replace(/\\/g, '').slice(0, -1))) }
+  await contract(new RedisStore(c))
+})
+
+test('kontrak store: mongo (collection palsu)', async () => {
+  const m = new Map()
+  const col = {
+    findOne: async ({ _id }) => m.get(_id) ?? null,
+    replaceOne: async ({ _id }, doc) => void m.set(_id, doc),
+    deleteOne: async ({ _id }) => void m.delete(_id),
+    find: ({ _id: { $regex } }) => ({ toArray: async () => [...m.values()].filter((d) => new RegExp($regex).test(d._id)) })
+  }
+  await contract(new MongoStore(col))
+})
+
+test('FileStore: tulis atomik, tulis berurutan, tmp dibersihkan, file rusak dikarantina', async () => {
+  const dir = tmp()
+  fs.writeFileSync(path.join(dir, 'sisa.json.1.abcd.tmp'), 'setengah')
+  const s = new FileStore(dir)
+  assert.equal(fs.readdirSync(dir).some((f) => f.endsWith('.tmp')), false)
+
+  await Promise.all(Array.from({ length: 50 }, (_, i) => s.set('k', { i })))
+  assert.equal((await s.get('k')).i, 49) // urutan terjaga
+  assert.deepEqual(fs.readdirSync(dir).filter((f) => f.endsWith('.tmp')), [])
+
+  fs.writeFileSync(path.join(dir, 'rusak.json'), '{"setengah":')
+  assert.equal(await s.get('rusak'), undefined)
+  assert.ok(fs.readdirSync(dir).some((f) => f.startsWith('rusak.json.') && f.endsWith('.corrupt')))
+})
+
+test('FileStore: kegagalan rename tidak merusak file lama', async () => {
+  const dir = tmp()
+  const s = new FileStore(dir)
+  await s.set('k', { v: 'lama' })
+  const orig = fs.promises.rename
+  fs.promises.rename = async () => { throw new Error('mati di tengah') }
+  try { await assert.rejects(s.set('k', { v: 'baru' }), /mati di tengah/) } finally { fs.promises.rename = orig }
+  assert.equal((await s.get('k')).v, 'lama')
+  assert.deepEqual(fs.readdirSync(dir).filter((f) => f.endsWith('.tmp')), [])
+})
+
+test('makeSocket + store: kunci dibuat sekali lalu dipakai ulang antar restart', async () => {
+  const store = new FileStore(tmp())
+  const a = makeSocket({ store, sessionId: 'nomor-a', autoConnect: false })
+  await a.ready
+  const k1 = a.creds.staticKey.public
+  const b = makeSocket({ store, sessionId: 'nomor-a', autoConnect: false })
+  await b.ready
+  assert.deepEqual(b.creds.staticKey.public, k1)
+  assert.ok(Buffer.isBuffer(b.creds.staticKey.private))
+  const c = makeSocket({ store, sessionId: 'nomor-b', autoConnect: false })
+  await c.ready
+  assert.notDeepEqual(c.creds.staticKey.public, k1)
+})
+
+test('SessionManager: banyak sesi, list, close + purge', async () => {
+  const store = new MemoryStore()
+  const mgr = createSessionManager({ store, autoConnect: false })
+  const a = mgr.open('a'), b = mgr.open('b')
+  assert.equal(mgr.open('a'), a)
+  await Promise.all([a.ready, b.ready])
+  assert.deepEqual((await mgr.list()).sort(), ['a', 'b'])
+  assert.equal(Object.keys(mgr.stats().sessions).length, 2)
+  await mgr.close('a', { purge: true })
+  assert.deepEqual(await mgr.list(), ['b'])
+  assert.throws(() => mgr.open('x:y'), /tidak valid/)
+  await mgr.closeAll()
+})
+
+test('LRUCache: batas entri, batas byte, TTL, urutan pakai', async () => {
+  const evicted = []
+  const c = new LRUCache({ max: 2, onEvict: (k, v, why) => evicted.push([k, why]) })
+  c.set('a', 1).set('b', 2); c.get('a'); c.set('c', 3)
+  assert.equal(c.has('b'), false); assert.equal(c.get('a'), 1)
+  assert.deepEqual(evicted, [['b', 'evicted']])
+
+  const m = new LRUCache({ max: 100, maxBytes: 10, sizeOf: (v) => v.length })
+  m.set('x', Buffer.alloc(6)); m.set('y', Buffer.alloc(6))
+  assert.equal(m.has('x'), false); assert.equal(m.bytes, 6)
+  m.set('gede', Buffer.alloc(50)) // entri tunggal raksasa tidak membuat cache kosong total
+  assert.equal(m.size, 1)
+
+  const t = new LRUCache({ ttl: 10 })
+  t.set('k', 1)
+  await new Promise((r) => setTimeout(r, 25))
+  assert.equal(t.get('k'), undefined)
+  assert.ok(c.stats().hitRate > 0)
+})
+
+test('multi-session: pairing lifecycle dan state tiap socket terisolasi', async () => {
+  const mgr = createSessionManager({ store: new MemoryStore(), autoConnect: false })
+  const a = mgr.open('nomor-a')
+  const b = mgr.open('nomor-b')
+  await Promise.all([a.ready, b.ready])
+  assert.notEqual(a.pairing, b.pairing)
+  a.pairing.begin('qr')
+  assert.equal(a.pairing.state, 'waiting-qr')
+  assert.equal(b.pairing.state, 'idle')
+  await mgr.closeAll()
+})

package/test/token-source.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const { parseGoTokenTable, validateTokenTable } = require('../src/wabinary/token-source')
+
+const fixture = String.raw`package token
+var (
+  SingleByteTokens = [...]string{"", "iq", "quoted\\\"token", "line\\nfeed", "hex\\x41"}
+  DoubleByteTokens = [...][]string{
+    {"first", "second"},
+    {"third"},
+    {},
+    {"fourth"},
+  }
+)
+const DictVersion = 7
+`
+
+test('Go token-data parser reads string escapes and page boundaries', () => {
+  const parsed = parseGoTokenTable(fixture)
+  assert.equal(parsed.dictVersion, 7)
+  assert.deepEqual(parsed.single, ['', 'iq', 'quoted\\"token', 'line\\nfeed', 'hex\\x41'])
+  assert.deepEqual(parsed.double, [['first', 'second'], ['third'], [], ['fourth']])
+})
+
+test('token-data validator rejects the wrong dictionary version', () => {
+  const table = { dictVersion: 2, single: Array(236).fill('x'), double: Array.from({ length: 4 }, () => Array(256).fill('x')) }
+  table.single[0] = ''
+  assert.throws(() => validateTokenTable(table, { dictVersion: 3 }), /DictVersion mismatch/)
+})
+
+test('token-data validator requires exact versioned table dimensions', () => {
+  assert.throws(() => validateTokenTable({ dictVersion: 3, single: [], double: [[], [], [], []] }), /single-byte token table shape unexpected/)
+})

package/test/wabinary.test.js

@@ -0,0 +1,147 @@
+'use strict'
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const zlib = require('node:zlib')
+const { encodeBinaryNode, decodeBinaryNode, TAGS } = require('../src/wabinary/codec')
+const { buildPairingQrPayload, extractPairingRefs, LINKED_DEVICES_PREFIX } = require('../src/pairing/qr')
+
+const emptyTokens = { single: [], double: [[], [], [], []] }
+
+test('WABinary: round-trip node attrs, nested children, strings and binary content', () => {
+  const input = {
+    tag: 'iq', attrs: { id: '42', type: 'result', to: 's.whatsapp.net' },
+    content: [
+      { tag: 'pair-device', attrs: {}, content: [{ tag: 'ref', attrs: {}, content: Buffer.from([0x01, 0x02, 0xff]) }] },
+      { tag: 'success', attrs: { t: '123' } }
+    ]
+  }
+  const wire = encodeBinaryNode(input, { tokens: emptyTokens })
+  const out = decodeBinaryNode(wire, { tokens: emptyTokens })
+  assert.equal(out.tag, 'iq')
+  assert.equal(out.attrs.id, '42')
+  assert.equal(out.content[0].tag, 'pair-device')
+  assert.deepEqual(out.content[0].content[0].content, Buffer.from([1, 2, 255]))
+  assert.equal(out.content[1].tag, 'success')
+})
+
+test('WABinary: raw JID pair, injected single/double token dictionaries', () => {
+  const tokens = { single: [null, 'iq', 'to'], double: [['pair-device'], [], [], []] }
+  const node = { tag: 'iq', attrs: { to: '123@s.whatsapp.net' }, content: [{ tag: 'pair-device', attrs: {} }] }
+  const out = decodeBinaryNode(encodeBinaryNode(node, { tokens }), { tokens })
+  assert.equal(out.tag, 'iq')
+  assert.equal(out.attrs.to, '123@s.whatsapp.net')
+  assert.equal(out.content[0].tag, 'pair-device')
+})
+
+test('WABinary: compressed and uncompressed transport prefixes', () => {
+  const node = { tag: 'message', attrs: { id: 'x' }, content: Buffer.from('hello') }
+  const raw = encodeBinaryNode(node, { tokens: emptyTokens })
+  const plain = decodeBinaryNode(raw, { tokens: emptyTokens })
+  const body = raw[0] === 0 ? raw.subarray(1) : raw
+  const compressed = decodeBinaryNode(Buffer.concat([Buffer.from([2]), zlib.deflateSync(body)]), { tokens: emptyTokens })
+  for (const out of [plain, compressed]) {
+    assert.equal(out.tag, node.tag)
+    assert.equal(out.attrs.id, node.attrs.id)
+    assert.deepEqual(out.content, node.content)
+  }
+})
+
+test('WABinary: truncated/unknown token inputs fail closed', () => {
+  assert.throws(() => decodeBinaryNode(Buffer.from([TAGS.LIST_8]), { tokens: emptyTokens, decompress: false }), /terpotong/)
+  assert.throws(() => decodeBinaryNode(Buffer.from([TAGS.LIST_8, 1, 1]), { tokens: emptyTokens, decompress: false }), /token tunggal/)
+})
+
+
+
+test('WABinary default encoder emits protocol 0x00 prefix and a pinned golden byte sequence', () => {
+  const single = Array(236).fill('')
+  single[3] = 's.whatsapp.net'
+  single[4] = 'type'
+  single[8] = 'id'
+  single[17] = 'to'
+  single[25] = 'iq'
+  single[41] = 'get'
+  single[86] = 'ping'
+  const tokens = { single, double: [Array(256).fill(''), Array(256).fill(''), Array(256).fill(''), Array(256).fill('')] }
+  const node = { tag: 'iq', attrs: { id: 'kersio-local-test', type: 'get', to: 's.whatsapp.net' }, content: [{ tag: 'ping', attrs: {} }] }
+  const expected = '00f8081908fc116b657273696f2d6c6f63616c2d7465737404291103f801f80156'
+  const encoded = encodeBinaryNode(node, { tokens })
+  assert.equal(encoded.toString('hex'), expected)
+  const decoded = decodeBinaryNode(encoded, { tokens })
+  assert.equal(decoded.tag, node.tag)
+  assert.deepEqual({ ...decoded.attrs }, node.attrs)
+  assert.equal(decoded.content[0].tag, 'ping')
+})
+
+test('WABinary packs digit/hex strings and round-trips device JID formats', () => {
+  const tokens = { single: [], double: [[], [], [], []] }
+  for (const value of ['1234567890', '12-34.56', 'ABCDEF09', '12345:2@s.whatsapp.net', '12345:7@lid', 'user@g.us']) {
+    const input = { tag: 'node', attrs: { value } }
+    const wire = encodeBinaryNode(input, { tokens })
+    assert.equal(wire[0], 0x00)
+    const output = decodeBinaryNode(wire, { tokens })
+    assert.equal(output.attrs.value, value)
+  }
+  const packed = encodeBinaryNode({ tag: 'x', attrs: { v: '12345' } }, { tokens })
+  assert.ok(packed.includes(0xff)) // HEX_8 or NIBBLE_8 marker in encoded attributes
+})
+
+
+
+test('WABinary decodes FB_JID and INTEROP_JID marker fixtures', () => {
+  const rawString = (value) => {
+    const b = Buffer.from(value, 'utf8')
+    assert.ok(b.length < 256)
+    return Buffer.concat([Buffer.from([TAGS.BINARY_8, b.length]), b])
+  }
+  const wrapValue = (encodedValue) => Buffer.concat([
+    Buffer.from([0x00, TAGS.LIST_8, 3]), rawString('x'), rawString('jid'), encodedValue
+  ])
+  const fb = Buffer.concat([Buffer.from([TAGS.FB_JID]), rawString('alice'), Buffer.from([0x00, 0x02]), rawString('s.whatsapp.net')])
+  const fbNode = decodeBinaryNode(wrapValue(fb), { tokens: emptyTokens, requirePrefix: true })
+  assert.equal(fbNode.attrs.jid, 'alice:2@s.whatsapp.net')
+
+  const interop = Buffer.concat([Buffer.from([TAGS.INTEROP_JID]), rawString('user'), Buffer.from([0x00, 0x07, 0x00, 0x03]), rawString('interop.example')])
+  const interopNode = decodeBinaryNode(wrapValue(interop), { tokens: emptyTokens, requirePrefix: true })
+  assert.equal(interopNode.attrs.jid, '3-user:7@interop.example')
+})
+
+test('WABinary leaves lowercase hex-looking text as raw UTF-8 and normalizes AD_JID device zero', () => {
+  const tokens = { single: [], double: [[], [], [], []] }
+  const lower = { tag: 'x', attrs: { value: 'deadbeef' } }
+  const lowerBytes = encodeBinaryNode(lower, { tokens })
+  assert.deepEqual(decodeBinaryNode(lowerBytes, { tokens }).attrs.value, 'deadbeef')
+  const encoded = encodeBinaryNode({ tag: 'x', attrs: { jid: '123:0@s.whatsapp.net' } }, { tokens })
+  const decoded = decodeBinaryNode(encoded, { tokens })
+  assert.equal(decoded.attrs.jid, '123@s.whatsapp.net')
+})
+
+test('WABinary compression option emits 0x02 prefix and respects output limits', () => {
+  const tokens = { single: [], double: [[], [], [], []] }
+  const node = { tag: 'message', attrs: { id: 'a'.repeat(2000) }, content: Buffer.from('payload') }
+  const compressed = encodeBinaryNode(node, { tokens, compress: true })
+  assert.equal(compressed[0], 0x02)
+  const decoded = decodeBinaryNode(compressed, { tokens })
+  assert.equal(decoded.tag, node.tag)
+  assert.equal(decoded.attrs.id, node.attrs.id)
+  assert.deepEqual(decoded.content, node.content)
+  assert.throws(() => encodeBinaryNode(node, { tokens, limits: { maxBytes: 100 } }), /maxBytes/)
+})
+
+test('pairing QR helper formats the observed fields and extracts pair-device refs', () => {
+  const payload = buildPairingQrPayload({
+    ref: Buffer.from('ref-1'), noisePublicKey: Buffer.alloc(32, 1),
+    identityPublicKey: Buffer.alloc(32, 2), advSecretKey: Buffer.alloc(32, 3), clientType: '1'
+  })
+  assert.ok(payload.startsWith(LINKED_DEVICES_PREFIX + 'ref-1,'))
+  const refs = extractPairingRefs({ tag: 'iq', attrs: {}, content: [{ tag: 'pair-device', attrs: {}, content: [
+    { tag: 'ref', attrs: {}, content: Buffer.from('ref-a') },
+    { tag: 'ref', attrs: {}, content: Buffer.from('ref-b') },
+    { tag: 'not-ref', attrs: {}, content: Buffer.from('ignore') }
+  ] }] })
+  assert.deepEqual(refs, [Buffer.from('ref-a'), Buffer.from('ref-b')])
+})
+
+test('pairing QR helper rejects incomplete key material', () => {
+  assert.throws(() => buildPairingQrPayload({ ref: 'ref', noisePublicKey: Buffer.alloc(31), identityPublicKey: Buffer.alloc(32), advSecretKey: Buffer.alloc(32), clientType: '1' }), /32 byte/)
+})