kersiosocket 0.0.0-stage → 0.6.0-dev

package/src/session/stores.js

@@ -0,0 +1,154 @@
+'use strict'
+/**
+ * Store session. Satu interface untuk semua backend:
+ *
+ *   get(key)            -> Promise<value | undefined>
+ *   set(key, value)     -> Promise<void>
+ *   delete(key)         -> Promise<void>
+ *   keys(prefix?)       -> Promise<string[]>   (opsional, dipakai daftar sesi)
+ *   close?()            -> Promise<void>
+ *
+ * Mau backend sendiri? Cukup buat objek dengan get/set/delete.
+ */
+const fs = require('node:fs')
+const fsp = fs.promises
+const path = require('node:path')
+const crypto = require('node:crypto')
+const { encode, decode } = require('./codec')
+
+/** Store di memori. Untuk test atau sesi sementara. */
+class MemoryStore {
+  constructor() { this.m = new Map() }
+  async get(key) { const v = this.m.get(key); return v === undefined ? undefined : decode(v) }
+  async set(key, value) { this.m.set(key, encode(value)) }
+  async delete(key) { this.m.delete(key) }
+  async keys(prefix = '') { return [...this.m.keys()].filter((k) => k.startsWith(prefix)) }
+}
+
+// Nama file aman di Windows/Linux/Termux, dan bisa dibalik jadi key asli.
+const fileName = (key) => encodeURIComponent(key).replace(/\./g, '%2E').replace(/\*/g, '%2A') + '.json'
+const keyOf = (name) => decodeURIComponent(name.slice(0, -5))
+
+/**
+ * Store file. Satu key = satu file JSON.
+ * Penulisan atomik: tulis ke file sementara, fsync, lalu rename. Bila proses mati di tengah
+ * penulisan, file lama tetap utuh. File yang rusak dipindah ke *.corrupt, bukan dihapus.
+ */
+class FileStore {
+  constructor(dir, { fsync = true } = {}) {
+    this.dir = path.resolve(dir)
+    this.fsync = fsync
+    this.queues = new Map() // key -> promise terakhir; menjaga urutan tulis per key
+    fs.mkdirSync(this.dir, { recursive: true })
+    for (const f of fs.readdirSync(this.dir)) if (f.endsWith('.tmp')) fs.rmSync(path.join(this.dir, f), { force: true })
+  }
+
+  _file(key) { return path.join(this.dir, fileName(key)) }
+
+  async get(key) {
+    const file = this._file(key)
+    let text
+    try { text = await fsp.readFile(file, 'utf8') } catch (e) {
+      if (e.code === 'ENOENT') return undefined
+      throw e
+    }
+    try { return decode(text) } catch {
+      await fsp.rename(file, `${file}.${Date.now()}.corrupt`).catch(() => {})
+      return undefined
+    }
+  }
+
+  set(key, value) { return this._queue(key, () => this._writeAtomic(this._file(key), encode(value))) }
+
+  delete(key) { return this._queue(key, () => fsp.rm(this._file(key), { force: true })) }
+
+  async keys(prefix = '') {
+    const names = await fsp.readdir(this.dir)
+    return names.filter((n) => n.endsWith('.json')).map(keyOf).filter((k) => k.startsWith(prefix))
+  }
+
+  _queue(key, job) {
+    const prev = this.queues.get(key) || Promise.resolve()
+    const next = prev.catch(() => {}).then(job)
+    this.queues.set(key, next)
+    const clean = () => { if (this.queues.get(key) === next) this.queues.delete(key) }
+    next.then(clean, clean)
+    return next
+  }
+
+  async _writeAtomic(file, text) {
+    const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`
+    const fh = await fsp.open(tmp, 'w')
+    try {
+      await fh.writeFile(text)
+      if (this.fsync) await fh.sync()
+    } finally { await fh.close() }
+    try { await fsp.rename(tmp, file) } catch (e) { await fsp.rm(tmp, { force: true }); throw e }
+  }
+}
+
+/** Store SQLite memakai node:sqlite bawaan Node (>= 22.5). Tanpa dependensi. */
+class SQLiteStore {
+  constructor(file = ':memory:') {
+    let DatabaseSync
+    try { ({ DatabaseSync } = require('node:sqlite')) } catch {
+      throw new Error('SQLiteStore butuh node:sqlite (Node >= 22.5)')
+    }
+    this.db = new DatabaseSync(file)
+    this.db.exec('PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; CREATE TABLE IF NOT EXISTS kv (k TEXT PRIMARY KEY, v TEXT NOT NULL) WITHOUT ROWID')
+    this._get = this.db.prepare('SELECT v FROM kv WHERE k = ?')
+    this._set = this.db.prepare('INSERT INTO kv (k, v) VALUES (?, ?) ON CONFLICT(k) DO UPDATE SET v = excluded.v')
+    this._del = this.db.prepare('DELETE FROM kv WHERE k = ?')
+    this._keys = this.db.prepare("SELECT k FROM kv WHERE substr(k, 1, ?) = ?")
+  }
+  async get(key) { const r = this._get.get(key); return r ? decode(r.v) : undefined }
+  async set(key, value) { this._set.run(key, encode(value)) }
+  async delete(key) { this._del.run(key) }
+  async keys(prefix = '') { return this._keys.all(prefix.length, prefix).map((r) => r.k) }
+  async close() { this.db.close() }
+}
+
+/**
+ * Adapter Redis. Berikan klien yang SUDAH dibuat (node-redis v4+ atau ioredis).
+ * Library ini tidak ikut membawa dependensi Redis.
+ */
+class RedisStore {
+  constructor(client, { prefix = 'kersio:' } = {}) { this.c = client; this.prefix = prefix }
+  async get(key) { const v = await this.c.get(this.prefix + key); return v == null ? undefined : decode(String(v)) }
+  async set(key, value) { await this.c.set(this.prefix + key, encode(value)) }
+  async delete(key) { await this.c.del(this.prefix + key) }
+  async keys(prefix = '') {
+    const pattern = `${this.prefix}${prefix}`.replace(/[\\*?\[\]]/g, '\\$&') + '*'
+    const out = []
+    if (typeof this.c.scanIterator === 'function') {
+      for await (const batch of this.c.scanIterator({ MATCH: pattern, COUNT: 200 })) {
+        for (const k of Array.isArray(batch) ? batch : [batch]) out.push(k)
+      }
+    } else out.push(...(await this.c.keys(pattern)))
+    return out.map((k) => k.slice(this.prefix.length))
+  }
+}
+
+/** Adapter MongoDB. Berikan objek collection dari driver `mongodb`. */
+class MongoStore {
+  constructor(collection) { this.col = collection }
+  async get(key) { const d = await this.col.findOne({ _id: key }); return d ? decode(d.v) : undefined }
+  async set(key, value) { await this.col.replaceOne({ _id: key }, { _id: key, v: encode(value) }, { upsert: true }) }
+  async delete(key) { await this.col.deleteOne({ _id: key }) }
+  async keys(prefix = '') {
+    const re = '^' + prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    return (await this.col.find({ _id: { $regex: re } }, { projection: { _id: 1 } }).toArray()).map((d) => d._id)
+  }
+}
+
+/** Bungkus store dengan namespace: semua key diawali `${ns}:`. */
+function scoped(store, ns) {
+  const p = `${ns}:`
+  return {
+    get: (k) => store.get(p + k),
+    set: (k, v) => store.set(p + k, v),
+    delete: (k) => store.delete(p + k)
+  }
+}
+
+module.exports = { MemoryStore, FileStore, SQLiteStore, RedisStore, MongoStore, scoped }

package/src/socket/connection.js

@@ -0,0 +1,278 @@
+'use strict'
+/**
+ * Connection: WebSocket + Noise handshake + reconnect (exponential backoff + jitter).
+ *
+ * Event:
+ *   connection.update  { connection: 'connecting'|'handshaking'|'noise-ready'|'close', ... }
+ *   frame              Buffer plaintext hasil dekripsi Noise
+ *   connection.error   Error protokol/transport
+ *   handler.error      Error sinkron/async dari satu listener; listener lain tetap dipanggil
+ */
+const { EventEmitter } = require('node:events')
+const { createTransport } = require('./transport')
+const { FrameDecoder, encodeFrame } = require('./frame')
+const { ClientHandshake, WA_HEADER } = require('./noise')
+const { generateKeyPair, EMPTY } = require('../utils/crypto')
+const { LatencyTracker } = require('../utils/latency')
+const { encodeClientPayload } = require('../proto/client-payload')
+
+const noopLog = { debug() {}, info() {}, warn() {}, error() {} }
+
+const DEFAULTS = {
+  url: 'wss://web.whatsapp.com/ws/chat',
+  origin: 'https://web.whatsapp.com',
+  clientPayload: EMPTY, // empty buffer is transport smoke-test only; real login needs verified auth payload
+  // Fail closed by default: callers must supply a pinned, independently tested server-certificate verifier.
+  strictServerCertificateVerification: true,
+  verifyServerCertificate: null,
+  // stableMs: koneksi baru dianggap 'sehat' (counter backoff direset) kalau bertahan selama ini
+  reconnect: { enabled: true, minDelay: 1000, maxDelay: 30000, factor: 2, stableMs: 30000 }
+}
+
+class Connection extends EventEmitter {
+  constructor(config = {}) {
+    super()
+    this.config = { ...DEFAULTS, ...config, reconnect: { ...DEFAULTS.reconnect, ...config.reconnect } }
+    this.log = config.logger || noopLog
+    const requestedPayload = this.config.clientPayload
+    if (Buffer.isBuffer(requestedPayload) || requestedPayload instanceof Uint8Array) {
+      this.clientPayload = Buffer.from(requestedPayload.buffer, requestedPayload.byteOffset, requestedPayload.byteLength)
+    } else if (requestedPayload && typeof requestedPayload === 'object') {
+      this.clientPayload = encodeClientPayload(requestedPayload)
+    } else {
+      throw new TypeError('clientPayload harus Buffer atau objek ClientPayload')
+    }
+    this.staticKey = config.staticKey || generateKeyPair()
+    this.state = 'close'
+    this.ended = false
+    this.attempt = 0
+    this.startedAt = 0
+    this.readyAt = 0
+    this.counters = { bytesIn: 0, bytesOut: 0, framesIn: 0, framesOut: 0 }
+    this.frameLatency = new LatencyTracker() // dekripsi + dispatch per frame
+    this.handshakeMs = 0
+    this.serverCertificateVerified = false
+    this._t = null
+    this._decoder = null
+    this._hs = null
+    this._noise = null
+    this._timer = null
+    this._generation = 0
+    this._closeHandled = false
+  }
+
+  connect() {
+    if (this._t) return
+    clearTimeout(this._timer)
+    this._timer = null
+    this.ended = false
+    this._setState('connecting')
+    const factory = this.config.transportFactory || createTransport
+    let t
+    try {
+      t = factory(this.config.url, { origin: this.config.origin, headers: this.config.headers })
+    } catch (err) {
+      this._safeEmit('connection.error', err)
+      this._setState('close', { error: err })
+      this._scheduleReconnect()
+      return
+    }
+    this._t = t
+    const generation = ++this._generation
+    this._closeHandled = false
+    t.on('open', () => {
+      if (this._t !== t || generation !== this._generation) return
+      try { this._onOpen() } catch (err) { this._abortConnection(err, t, generation) }
+    })
+    t.on('message', (d) => {
+      if (this._t !== t || generation !== this._generation) return
+      this._onMessage(d)
+    })
+    t.on('close', (code, reason) => this._onClose(code, reason, t, generation))
+    t.on('transport.error', (err) => {
+      if (this._t === t && generation === this._generation) this._safeEmit('connection.error', err)
+    })
+  }
+
+  end() {
+    this.ended = true
+    clearTimeout(this._timer)
+    if (this._t) this._t.close()
+  }
+
+  /** Kirim data (plaintext) lewat kanal Noise terenkripsi. */
+  sendFrame(plain) {
+    if (this.state !== 'noise-ready') throw new Error('koneksi belum siap (handshake belum selesai)')
+    this._write(encodeFrame(this._noise.encrypt(plain)))
+  }
+
+  stats() {
+    const m = process.memoryUsage()
+    return {
+      state: this.state,
+      uptimeMs: this.startedAt ? Date.now() - this.startedAt : 0,
+      ...this.counters,
+      handshakeMs: this.handshakeMs,
+      frameLatencyMs: this.frameLatency.summary(),
+      serverCertificateVerified: this.serverCertificateVerified,
+      rssMB: +(m.rss / 1048576).toFixed(1),
+      heapUsedMB: +(m.heapUsed / 1048576).toFixed(1)
+    }
+  }
+
+  _setState(connection, extra) {
+    this.state = connection
+    this._safeEmit('connection.update', { connection, ...extra })
+  }
+
+  _write(buf) {
+    this.counters.bytesOut += buf.length
+    this.counters.framesOut++
+    this._t.send(buf)
+  }
+
+  _onOpen() {
+    this._decoder = new FrameDecoder()
+    this._hs = new ClientHandshake({
+      staticKey: this.staticKey,
+      verifyServerCertificate: this.config.verifyServerCertificate,
+      requireServerCertificateVerification: this.config.strictServerCertificateVerification
+    })
+    this.startedAt = Date.now()
+    this._setState('handshaking')
+    this._write(encodeFrame(this._hs.hello(), WA_HEADER))
+  }
+
+  _onMessage(chunk) {
+    if (!this._decoder || !this._t) return
+    try {
+      this.counters.bytesIn += chunk && typeof chunk.length === 'number' ? chunk.length : 0
+      const frames = this._decoder.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))
+      for (const frame of frames) {
+        if (!this._t) break
+        this.counters.framesIn++
+        try {
+          this._onFrame(frame)
+        } catch (err) {
+          this._abortConnection(err, this._t, this._generation)
+          break
+        }
+      }
+    } catch (err) {
+      this._abortConnection(err, this._t, this._generation)
+    }
+  }
+
+  _onFrame(frame) {
+    if (this._hs) {
+      const hs = this._hs
+      const finish = hs.processServerHello(frame, this.clientPayload)
+      this._noise = hs.noise
+      this.serverCertificateVerified = hs.serverCertificateVerified === true
+      this._hs = null
+      // Publish the completed Noise state before writing ClientFinish. A fake or
+      // custom transport may synchronously deliver the server reply from send().
+      this.readyAt = Date.now()
+      this.handshakeMs = Date.now() - this.startedAt
+      this._setState('noise-ready', {
+        serverStatic: hs.serverStatic,
+        serverCertificateVerified: this.serverCertificateVerified
+      })
+      this._write(encodeFrame(finish))
+      return
+    }
+    if (!this._noise) throw new Error('Noise state tidak tersedia di luar handshake')
+    const done = this.frameLatency.start()
+    try {
+      const plain = this._noise.decrypt(frame)
+      this._safeEmit('frame', plain)
+    } finally {
+      done()
+    }
+  }
+
+  /** Dispatch each listener independently, so one user callback cannot starve others. */
+  _safeEmit(event, ...args) {
+    const listeners = this.rawListeners(event)
+    if (listeners.length === 0) return false
+    for (const listener of listeners) {
+      try {
+        const result = Reflect.apply(listener, this, args)
+        if (result && typeof result.then === 'function') {
+          Promise.resolve(result).catch((err) => this._reportHandlerError(err, event))
+        }
+      } catch (err) {
+        this._reportHandlerError(err, event)
+      }
+    }
+    return true
+  }
+
+  _reportHandlerError(error, sourceEvent) {
+    const err = error instanceof Error ? error : new Error(String(error))
+    this.log.error(`listener '${sourceEvent}' melempar error: ${err.message}`)
+    if (sourceEvent === 'handler.error') return
+    const listeners = this.rawListeners('handler.error')
+    for (const listener of listeners) {
+      try {
+        const result = Reflect.apply(listener, this, [err, sourceEvent])
+        if (result && typeof result.then === 'function') {
+          Promise.resolve(result).catch((nested) => this.log.error(`listener 'handler.error' melempar error: ${nested.message}`))
+        }
+      } catch (nested) {
+        this.log.error(`listener 'handler.error' melempar error: ${nested.message}`)
+      }
+    }
+  }
+
+  _abortConnection(error, transport = this._t, generation = this._generation) {
+    const err = error instanceof Error ? error : new Error(String(error))
+    this._safeEmit('connection.error', err)
+    if (['ERR_NOISE_CERTIFICATE_VERIFIER_MISSING', 'ERR_NOISE_CERTIFICATE_REJECTED'].includes(err.code)) {
+      // Configuration/trust failures are not transient network failures. Stop auto-retry.
+      this.ended = true
+    }
+    if (!transport || transport !== this._t || generation !== this._generation) return
+    // Transition/cleanup synchronously. The transport's eventual close event is de-duplicated.
+    this._onClose(1002, Buffer.from('protocol/transport failure'), transport, generation)
+    try { transport.close() } catch (closeError) {
+      this.log.warn(`gagal menutup transport: ${closeError.message}`)
+    }
+  }
+
+  _onClose(code, reason, source = this._t, generation = this._generation) {
+    if (!source || source !== this._t || generation !== this._generation || this._closeHandled) return
+    this._closeHandled = true
+    const lived = this.readyAt ? Date.now() - this.readyAt : 0
+    const wasReady = this.readyAt > 0
+    this.readyAt = 0
+    this._t = this._hs = this._noise = this._decoder = null
+    this._setState('close', { code, reason: Buffer.isBuffer(reason) ? reason.toString('utf8') : reason })
+    const r = this.config.reconnect
+    if (lived >= r.stableMs) this.attempt = 0
+    else if (wasReady && this.clientPayload.length === 0) {
+      this.log.warn('server menutup koneksi tepat setelah handshake: clientPayload masih kosong (login/registrasi belum diimplementasi)')
+    }
+    this._scheduleReconnect()
+  }
+
+  _scheduleReconnect() {
+    const r = this.config.reconnect
+    if (this.ended || !r.enabled || this._timer) return
+    const base = Math.min(r.maxDelay, r.minDelay * Math.pow(r.factor, this.attempt++))
+    const delay = Math.round(base * (0.8 + Math.random() * 0.4))
+    this.log.info(`reconnect dalam ${delay}ms (percobaan ${this.attempt})`)
+    this._timer = setTimeout(() => {
+      this._timer = null
+      if (!this.ended && !this._t) this.connect()
+    }, delay)
+  }
+
+  /** Fail a decrypted protocol frame closed, while preserving configured backoff behavior. */
+  failProtocol(error) {
+    this._abortConnection(error)
+  }
+
+}
+
+module.exports = { Connection }

package/src/socket/frame.js

@@ -0,0 +1,77 @@
+'use strict'
+/**
+ * Framing WhatsApp: [prefix opsional][panjang 3 byte big-endian][payload].
+ * Prefix (WA_HEADER) hanya dikirim di frame pertama.
+ */
+const MAX_FRAME = 0xffffff
+
+function encodeFrame(payload, prefix) {
+  if (payload.length > MAX_FRAME) throw new Error('frame terlalu besar')
+  const head = Buffer.allocUnsafe(3)
+  head[0] = payload.length >>> 16
+  head[1] = (payload.length >>> 8) & 0xff
+  head[2] = payload.length & 0xff
+  return prefix ? Buffer.concat([prefix, head, payload]) : Buffer.concat([head, payload])
+}
+
+/**
+ * Penyusun frame dari potongan data WebSocket (frame bisa terbelah/menyatu).
+ * Potongan disimpan dalam daftar dan baru digabung SEKALI saat satu frame lengkap,
+ * jadi frame besar yang datang bertahap tidak memicu concat berulang (O(n^2)).
+ * Sisa data yang belum lengkap disalin supaya tidak menahan buffer induk yang besar.
+ */
+class FrameDecoder {
+  constructor() {
+    this.chunks = []
+    this.total = 0
+    this.need = 0 // total byte (header + payload) frame yang sedang dirakit; 0 = belum tahu
+  }
+
+  push(chunk) {
+    if (chunk.length) { this.chunks.push(chunk); this.total += chunk.length }
+    const frames = []
+    for (;;) {
+      if (this.need === 0) {
+        if (this.total < 3) break
+        this.need = 3 + ((this._byte(0) << 16) | (this._byte(1) << 8) | this._byte(2))
+      }
+      if (this.total < this.need) break
+      frames.push(this._take(this.need).subarray(3))
+      this.need = 0
+    }
+    if (this.chunks.length === 1 && this.chunks[0].length) this.chunks[0] = Buffer.from(this.chunks[0])
+    return frames
+  }
+
+  _byte(i) {
+    for (const c of this.chunks) {
+      if (i < c.length) return c[i]
+      i -= c.length
+    }
+    return 0
+  }
+
+  /** Ambil n byte dari depan. Tanpa salinan bila seluruhnya ada di satu potongan. */
+  _take(n) {
+    const first = this.chunks[0]
+    this.total -= n
+    if (first.length >= n) {
+      if (first.length === n) this.chunks.shift()
+      else this.chunks[0] = first.subarray(n)
+      return first.subarray(0, n)
+    }
+    const out = Buffer.allocUnsafe(n)
+    let off = 0
+    while (off < n) {
+      const c = this.chunks[0]
+      const take = Math.min(c.length, n - off)
+      c.copy(out, off, 0, take)
+      off += take
+      if (take === c.length) this.chunks.shift()
+      else this.chunks[0] = c.subarray(take)
+    }
+    return out
+  }
+}
+
+module.exports = { encodeFrame, FrameDecoder, MAX_FRAME }

package/src/socket/make.js

@@ -0,0 +1,70 @@
+'use strict'
+const { Connection } = require('./connection')
+const { generateKeyPair } = require('../utils/crypto')
+const { scoped } = require('../session/stores')
+const { PairingLifecycle } = require('../pairing/lifecycle')
+const { NodeProtocol } = require('../protocol/node-protocol')
+
+/**
+ * Buat socket kersiosocket.
+ *
+ * @param {object} [config]
+ *   autoConnect  true  -> sambung otomatis (default)
+ *   store        store session {get,set,delete}; bila ada, kredensial disimpan/dimuat otomatis
+ *   sessionId    nama sesi di dalam store (default 'default')
+ *   logger, reconnect, url, origin, staticKey, clientPayload
+ *
+ * Event (sock.ev): connection.update, creds.update, frame, connection.error, handler.error
+ * sock.ready: Promise yang selesai setelah kredensial dimuat (dan koneksi dimulai bila autoConnect).
+ */
+function makeSocket(config = {}) {
+  const conn = new Connection(config)
+  const pairing = new PairingLifecycle({ sessionId: config.sessionId || 'default' })
+  const protocolConfig = config.nodeProtocol
+  const protocol = protocolConfig ? new NodeProtocol(conn, protocolConfig === true ? {} : protocolConfig) : null
+  const store = config.store ? scoped(config.store, config.sessionId || 'default') : null
+  let creds = null
+
+  const saveCreds = async () => {
+    if (!store || !creds) return
+    await store.set('creds', creds)
+    conn._safeEmit('creds.update', creds)
+  }
+
+  const start = async () => {
+    if (store) {
+      creds = (await store.get('creds')) || null
+      if (!creds) {
+        creds = { staticKey: config.staticKey || generateKeyPair(), createdAt: Date.now() }
+        await saveCreds()
+      }
+      conn.staticKey = creds.staticKey
+    }
+    if (config.autoConnect !== false) conn.connect()
+  }
+
+  const sock = {
+    ev: conn,
+    sessionId: config.sessionId || 'default',
+    pairing,
+    connect: () => conn.connect(),
+    end: () => { protocol?.close(); pairing.close(); conn.end() },
+    sendFrame: (buf) => conn.sendFrame(buf),
+    protocol,
+    sendNode: (node) => { if (!protocol) throw new Error('aktifkan nodeProtocol pada makeSocket() untuk sendNode()'); return protocol.sendNode(node) },
+    query: (node, options) => { if (!protocol) return Promise.reject(new Error('aktifkan nodeProtocol pada makeSocket() untuk query()')); return protocol.query(node, options) },
+    stats: () => conn.stats(),
+    saveCreds,
+    get creds() { return creds },
+    get state() { return conn.state }
+  }
+
+  // tunda satu tick supaya pemanggil sempat memasang listener
+  sock.ready = new Promise((resolve) => process.nextTick(resolve))
+    .then(start)
+    .catch((err) => { conn._safeEmit('connection.error', err) })
+
+  return sock
+}
+
+module.exports = { makeSocket }