luang-cli 0.2.0 → 0.3.0

package/test/ws-stub.js

@@ -0,0 +1,202 @@
+'use strict';
+
+// test/ws-stub.js — stub server WebSocket minimal (sisi server RFC 6455)
+// untuk E2E offline luang-cli. Bukan bagian dari paket npm; hanya alat uji.
+// Menangani: handshake 101 (verifikasi X-CLI-Key), frame client→server
+// (unmask), ping→pong, close; mengirim text frame ke client.
+
+const crypto = require('crypto');
+const net = require('net');
+
+const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+
+function extractServerFrame(buf) {
+  if (!buf || buf.length < 2) return null;
+  const b0 = buf[0];
+  const b1 = buf[1];
+  const fin = (b0 & 0x80) !== 0;
+  const opcode = b0 & 0x0f;
+  const masked = (b1 & 0x80) !== 0;
+  let len = b1 & 0x7f;
+  let off = 2;
+  if (len === 126) {
+    if (buf.length < 4) return null;
+    len = buf.readUInt16BE(2);
+    off = 4;
+  } else if (len === 127) {
+    if (buf.length < 10) return null;
+    len = Number(buf.readBigUInt64BE(2));
+    off = 10;
+  }
+  const maskLen = masked ? 4 : 0;
+  const total = off + maskLen + len;
+  if (buf.length < total) return null;
+  const payload = Buffer.from(buf.subarray(off + maskLen, total));
+  if (masked) {
+    const mk = buf.subarray(off, off + 4);
+    for (let i = 0; i < payload.length; i++) payload[i] ^= mk[i & 3];
+  }
+  return { frame: { fin, opcode, payload }, rest: buf.subarray(total) };
+}
+
+function encodeServerFrame(opcode, payload) {
+  // frame server→client: TANPA mask
+  const len = payload.length;
+  let header;
+  if (len < 126) header = Buffer.allocUnsafe(2);
+  else if (len < 65536) {
+    header = Buffer.allocUnsafe(4);
+    header.writeUInt16BE(len, 2);
+  } else {
+    header = Buffer.allocUnsafe(10);
+    header.writeBigUInt64BE(BigInt(len), 2);
+  }
+  header[0] = 0x80 | opcode;
+  header[1] = len < 126 ? len : len < 65536 ? 126 : 127;
+  return Buffer.concat([header, payload]);
+}
+
+class StubWsServer {
+  constructor({ port, expectedKey, path = '/api/v1/agent/ws' } = {}) {
+    this.port = port;
+    this.expectedPath = path;
+    this.expectedKey = expectedKey || null;
+    this.conns = [];
+    this.frames = [];
+    this.onMsg = null;
+    this.onHandshake = null; // (info, rejectFn) → bila rejectFn dipanggil, handshake ditolak
+    this.closedConns = 0;
+    this.server = null;
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      const srv = net.createServer((sock) => this._onConn(sock));
+      srv.on('error', reject);
+      srv.listen(this.port, '127.0.0.1', () => {
+        this.server = srv;
+        resolve(this);
+      });
+    });
+  }
+
+  stop() {
+    return new Promise((resolve) => {
+      for (const c of this.conns) {
+        try { c.sock.destroy(); } catch (e) { /* abaikan */ }
+      }
+      if (!this.server) return resolve();
+      this.server.close(() => resolve());
+    });
+  }
+
+  broadcastText(text) {
+    const buf = encodeServerFrame(0x1, Buffer.from(text, 'utf8'));
+    for (const c of this.conns) {
+      try { c.sock.write(buf); } catch (e) { /* abaikan */ }
+    }
+  }
+
+  sendText(conn, text) {
+    try { conn.sock.write(encodeServerFrame(0x1, Buffer.from(text, 'utf8'))); } catch (e) { /* abaikan */ }
+  }
+
+  pingAll() {
+    // Biarkan CLI mendemokan rt: protocol ping 5 byte kecil
+    for (const c of this.conns) {
+      try { c.sock.write(encodeServerFrame(0x9, Buffer.from([0x01, 0x02]))); } catch (e) { /* abaikan */ }
+    }
+  }
+
+  killAll() {
+    // Putuskan semua koneksi secara mentah (TCP drop) — untuk uji reconnect.
+    for (const c of [...this.conns]) {
+      try { c.sock.destroy(); } catch (e) { /* abaikan */ }
+    }
+  }
+
+  _onConn(sock) {
+    const conn = { sock, buf: null, opened: false };
+    this.conns.push(conn);
+    sock.on('close', () => {
+      this.closedConns += 1;
+      const i = this.conns.indexOf(conn);
+      if (i >= 0) this.conns.splice(i, 1);
+    });
+    sock.on('data', (chunk) => {
+      conn.buf = conn.buf ? Buffer.concat([conn.buf, chunk]) : chunk;
+      if (!conn.opened) {
+        const idx = conn.buf.indexOf('\r\n\r\n');
+        if (idx === -1) return;
+        const head = conn.buf.subarray(0, idx).toString('utf8');
+        const rest = conn.buf.subarray(idx + 4);
+        const lines = head.split('\r\n');
+        const headers = {};
+        for (const line of lines.slice(1)) {
+          const ci = line.indexOf(':');
+          if (ci > 0) headers[line.slice(0, ci).trim().toLowerCase()] = line.slice(ci + 1).trim();
+        }
+        const target = (lines[0] || '').split(' ');
+        const reqPath = target[1] || '';
+        if (!reqPath.startsWith(this.expectedPath)) {
+          sock.write('HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n');
+          sock.destroy();
+          return;
+        }
+        if (this.expectedKey && headers['x-cli-key'] !== this.expectedKey) {
+          sock.write('HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n');
+          sock.destroy();
+          return;
+        }
+        const secKey = headers['sec-websocket-key'];
+        if (!secKey) {
+          sock.write('HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n');
+          sock.destroy();
+          return;
+        }
+        const accept = crypto.createHash('sha1').update(secKey + WS_GUID).digest('base64');
+        sock.write(
+          'HTTP/1.1 101 Switching Protocols\r\n' +
+          'Upgrade: websocket\r\n' +
+          'Connection: Upgrade\r\n' +
+          `Sec-WebSocket-Accept: ${accept}\r\n` +
+          '\r\n'
+        );
+        conn.opened = true;
+        conn.buf = rest && rest.length ? rest : null;
+        if (this.onHandshake) this.onHandshake({ headers }, null);
+        // lanjut parsing frame yang datang bersamaan dengan handshake
+        if (conn.buf) this._drain(conn);
+        return;
+      }
+      this._drain(conn);
+    });
+  }
+
+  _drain(conn) {
+    for (;;) {
+      const r = extractServerFrame(conn.buf);
+      if (!r) return;
+      conn.buf = r.rest && r.rest.length ? r.rest : null;
+      const { opcode, payload } = r.frame;
+      this.frames.push({ ts: Date.now(), opcode }); // semua opcode, untuk cek pong
+      if (opcode === 0x1 || opcode === 0x2) {
+        // payload client frame mungkin terfragmentasi — skenario kita tidak yang fragmentasi
+        let text = '';
+        try { text = payload.toString('utf8'); } catch (e) { text = ''; }
+        let obj = null;
+        try { obj = JSON.parse(text); } catch (e) { obj = null; }
+        Object.assign(this.frames[this.frames.length - 1], { raw: text, obj });
+        if (this.onMsg) this.onMsg({ ts: Date.now(), opcode, raw: text, obj }, conn, this);
+      } else if (opcode === 0x9) {
+        try { conn.sock.write(encodeServerFrame(0xa, payload)); } catch (e) { /* abaikan */ }
+      } else if (opcode === 0xa) {
+        // pong dari client — diabaikan
+      } else if (opcode === 0x8) {
+        try { conn.sock.end(encodeServerFrame(0x8, Buffer.from([0x03, 0xe8]))); } catch (e) { /* abaikan */ }
+      }
+    }
+  }
+}
+
+module.exports = { StubWsServer };