@kangwifi-pro/waliwa 1.0.0

package/examples/rest-gateway/index.ts

@@ -0,0 +1,499 @@
+/**
+ * REST API Gateway Example - HTTP endpoint untuk kirim pesan WhatsApp
+ *
+ * Features:
+ * - POST /send-text - Send text message
+ * - POST /send-media - Send image/video/audio
+ * - GET /status - Get connection status
+ * - GET /health - Health check
+ * - POST /webhook - Set webhook untuk incoming messages
+ * - GET /groups - List groups
+ * - POST /groups/create - Create new group
+ * - GET /contacts - List known contacts
+ *
+ * Setup:
+ *   1. npm install
+ *   2. npm start
+ *   3. Scan QR yang muncul
+ *   4. Setelah connected, test dengan curl:
+ *
+ *      curl -X POST http://localhost:3000/send-text \
+ *        -H "Content-Type: application/json" \
+ *        -d '{"to":"6281234567890","message":"Hello from API!"}'
+ *
+ * Security:
+ *   - Set API_KEY environment variable untuk auth (Bearer token)
+ *   - Set ALLOWED_IPS untuk IP whitelist
+ */
+
+import express, { Request, Response, NextFunction } from 'express';
+import {
+  makeWASocket,
+  useFileAuthState,
+  isGroupJid,
+  jidToString,
+  type WAMessage,
+  type JIDLike
+} from 'waliwa';
+
+// ============== Config ==============
+
+const CONFIG = {
+  port: parseInt(process.env.PORT ?? '3000', 10),
+  apiKey: process.env.API_KEY,
+  allowedIps: process.env.ALLOWED_IPS?.split(',').map(ip => ip.trim()) ?? [],
+  webhookUrl: process.env.WEBHOOK_URL,
+  rateLimitPerMinute: parseInt(process.env.RATE_LIMIT ?? '60', 10),
+  bodyLimit: '10mb'
+};
+
+// ============== App State ==============
+
+const app = express();
+app.use(express.json({ limit: CONFIG.bodyLimit }));
+app.use(express.urlencoded({ extended: true, limit: CONFIG.bodyLimit }));
+
+let sock: ReturnType<typeof makeWASocket> | null = null;
+let isReady = false;
+
+// Rate limiter per IP
+const rateLimiter = new Map<string, { count: number; resetAt: number }>();
+
+// Webhook subscribers
+const webhooks = new Set<string>();
+
+// ============== Auth Middleware ==============
+
+function authMiddleware(req: Request, res: Response, next: NextFunction): void {
+  // Check IP whitelist
+  if (CONFIG.allowedIps.length > 0) {
+    const clientIp = req.ip ?? req.socket.remoteAddress ?? '';
+    const cleanIp = clientIp.replace('::ffff:', '');
+    if (!CONFIG.allowedIps.includes(cleanIp)) {
+      res.status(403).json({ error: 'IP not allowed' });
+      return;
+    }
+  }
+
+  // Check API key
+  if (CONFIG.apiKey) {
+    const auth = req.headers.authorization;
+    if (auth !== `Bearer ${CONFIG.apiKey}`) {
+      res.status(401).json({ error: 'Unauthorized' });
+      return;
+    }
+  }
+
+  // Rate limit
+  const clientKey = req.ip ?? 'unknown';
+  const now = Date.now();
+  let entry = rateLimiter.get(clientKey);
+  if (!entry || now > entry.resetAt) {
+    entry = { count: 0, resetAt: now + 60000 };
+    rateLimiter.set(clientKey, entry);
+  }
+  if (entry.count >= CONFIG.rateLimitPerMinute) {
+    res.status(429).json({ error: 'Rate limit exceeded' });
+    return;
+  }
+  entry.count++;
+
+  next();
+}
+
+// ============== WhatsApp Connection ==============
+
+async function startWhatsApp() {
+  console.log('Starting WhatsApp connection...');
+  const { state } = await useFileAuthState('./auth');
+
+  sock = makeWASocket({
+    authState: state,
+    printQRInTerminal: true,
+    ramOptimizationLevel: 2,
+    maxReconnectAttempts: 10
+  });
+
+  sock.ev.on('connection.update', (update) => {
+    const { connection, qr } = update;
+    if (qr) console.log('Scan QR dengan WhatsApp mobile...');
+    if (connection === 'open') {
+      console.log('✓ WhatsApp connected as', sock!.user?.id);
+      isReady = true;
+    }
+    if (connection === 'close') {
+      console.log('Connection closed, reconnecting...');
+      isReady = false;
+    }
+  });
+
+  // Forward incoming messages ke webhook subscribers
+  sock.ev.on('message.upsert', async ({ messages }) => {
+    for (const message of messages) {
+      await forwardToWebhooks(message);
+    }
+  });
+
+  // Forward call events
+  sock.ev.on('calls', async (callEvent) => {
+    await forwardToWebhooks(callEvent, 'call');
+  });
+}
+
+// ============== Webhook Forwarding ==============
+
+async function forwardToWebhooks(payload: any, type: string = 'message'): Promise<void> {
+  if (webhooks.size === 0) return;
+
+  const body = JSON.stringify({
+    type,
+    timestamp: Date.now(),
+    data: payload
+  });
+
+  for (const url of webhooks) {
+    try {
+      await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body
+      });
+    } catch (err: any) {
+      console.error(`Webhook ${url} failed:`, err.message);
+    }
+  }
+}
+
+// ============== API Routes ==============
+
+// Health check
+app.get('/health', (req: Request, res: Response) => {
+  res.json({ status: 'ok', timestamp: Date.now() });
+});
+
+// Connection status
+app.get('/status', authMiddleware, (req: Request, res: Response) => {
+  res.json({
+    connected: isReady,
+    user: sock?.user,
+    timestamp: Date.now()
+  });
+});
+
+// Send text message
+app.post('/send-text', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+
+  const { to, message, mentions, quotedId } = req.body;
+
+  if (!to || !message) {
+    res.status(400).json({ error: 'Missing required fields: to, message' });
+    return;
+  }
+
+  try {
+    const jid = normalizeJid(to);
+    const content: any = { text: message };
+
+    if (mentions && Array.isArray(mentions)) {
+      content.mentions = mentions.map((m: string) => normalizeJid(m));
+    }
+
+    const result = await sock.sendMessage(jid, content);
+    res.json({
+      success: true,
+      messageId: result.key.id,
+      status: result.status,
+      timestamp: result.messageTimestamp
+    });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Send media (image, video, audio, document)
+app.post('/send-media', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+
+  const { to, type, base64, mimetype, caption, fileName } = req.body;
+
+  if (!to || !type || !base64 || !mimetype) {
+    res.status(400).json({ error: 'Missing required fields: to, type, base64, mimetype' });
+    return;
+  }
+
+  try {
+    const jid = normalizeJid(to);
+    const buffer = Buffer.from(base64, 'base64');
+
+    // First upload ke WhatsApp CDN
+    const uploadResult = await sock.uploadMedia(buffer, type, mimetype, fileName);
+
+    // Then send message dengan media reference
+    let content: any;
+    switch (type) {
+      case 'image':
+        content = {
+          image: { stream: buffer as any, mimetype },
+          caption
+        };
+        break;
+      case 'video':
+        content = {
+          video: { stream: buffer as any, mimetype },
+          caption
+        };
+        break;
+      case 'audio':
+        content = {
+          audio: { stream: buffer as any, mimetype }
+        };
+        break;
+      case 'document':
+        content = {
+          document: { stream: buffer as any, mimetype, fileName }
+        };
+        break;
+      default:
+        res.status(400).json({ error: `Unknown media type: ${type}` });
+        return;
+    }
+
+    const result = await sock.sendMessage(jid, content);
+    res.json({
+      success: true,
+      messageId: result.key.id,
+      status: result.status,
+      mediaUrl: uploadResult.url,
+      timestamp: result.messageTimestamp
+    });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Send reaction
+app.post('/send-reaction', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+
+  const { to, messageId, emoji } = req.body;
+  if (!to || !messageId || !emoji) {
+    res.status(400).json({ error: 'Missing required fields: to, messageId, emoji' });
+    return;
+  }
+
+  try {
+    const result = await sock.reactToMessage(
+      normalizeJid(to),
+      { remoteJid: normalizeJid(to), fromMe: false, id: messageId },
+      emoji
+    );
+    res.json({ success: true, status: result.status });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Delete message
+app.delete('/message', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+
+  const { to, messageId, revokeEveryone } = req.body;
+  if (!to || !messageId) {
+    res.status(400).json({ error: 'Missing required fields: to, messageId' });
+    return;
+  }
+
+  try {
+    const result = await sock.deleteMessage(
+      normalizeJid(to),
+      { remoteJid: normalizeJid(to), fromMe: true, id: messageId },
+      { revokeEveryone: revokeEveryone ?? false }
+    );
+    res.json({ success: true, status: result.status });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// List groups
+app.get('/groups', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+
+  // Note: Real implementation perlu query groups dari sync
+  // Simplified untuk example
+  res.json({
+    success: true,
+    groups: [],
+    note: 'Use specific group ID via /groups/:id for metadata'
+  });
+});
+
+// Get group metadata
+app.get('/groups/:jid', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+
+  try {
+    const metadata = await sock.groupMetadata(req.params.jid);
+    res.json({ success: true, metadata });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Create group
+app.post('/groups/create', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+
+  const { subject, participants, description } = req.body;
+  if (!subject || !participants || !Array.isArray(participants)) {
+    res.status(400).json({ error: 'Missing required: subject, participants[]' });
+    return;
+  }
+
+  try {
+    const metadata = await sock.groupCreate({
+      subject,
+      participants: participants.map((p: string) => normalizeJid(p)),
+      desc: description
+    });
+    res.json({ success: true, groupId: metadata.id, subject: metadata.subject });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Group participants management
+app.post('/groups/:jid/participants', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+
+  const { participants, action } = req.body;
+  if (!participants || !action) {
+    res.status(400).json({ error: 'Missing required: participants[], action' });
+    return;
+  }
+
+  if (!['add', 'remove', 'promote', 'demote'].includes(action)) {
+    res.status(400).json({ error: 'Invalid action' });
+    return;
+  }
+
+  try {
+    await sock.groupParticipantsUpdate(
+      req.params.jid,
+      participants.map((p: string) => normalizeJid(p)),
+      action
+    );
+    res.json({ success: true });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Get invite code
+app.get('/groups/:jid/invite', authMiddleware, async (req: Request, res: Response) => {
+  if (!isReady || !sock) {
+    res.status(503).json({ error: 'WhatsApp not connected' });
+    return;
+  }
+  try {
+    const code = await sock.groupInviteCode(req.params.jid);
+    res.json({ success: true, code, url: `https://chat.whatsapp.com/${code}` });
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Webhook management
+app.post('/webhook', authMiddleware, (req: Request, res: Response) => {
+  const { url, action } = req.body;
+  if (!url) {
+    res.status(400).json({ error: 'Missing required: url' });
+    return;
+  }
+  if (action === 'remove') {
+    webhooks.delete(url);
+  } else {
+    webhooks.add(url);
+  }
+  res.json({ success: true, webhooks: Array.from(webhooks) });
+});
+
+app.get('/webhooks', authMiddleware, (req: Request, res: Response) => {
+  res.json({ webhooks: Array.from(webhooks) });
+});
+
+// ============== Helpers ==============
+
+function normalizeJid(input: string): string {
+  // Remove non-digit chars dari phone number
+  const clean = input.replace(/[^0-9]/g, '');
+  // Jika sudah ada @, pakai apa adanya
+  if (input.includes('@')) return input;
+  // Jika 628... format, default ke s.whatsapp.net
+  return `${clean}@s.whatsapp.net`;
+}
+
+// ============== Error Handler ==============
+
+app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
+  console.error('Unhandled error:', err.message);
+  res.status(500).json({ error: 'Internal server error', message: err.message });
+});
+
+// ============== Start Server ==============
+
+async function main() {
+  await startWhatsApp();
+
+  app.listen(CONFIG.port, () => {
+    console.log(`\n=== Waliwa REST API Gateway ===`);
+    console.log(`Listening on http://localhost:${CONFIG.port}`);
+    console.log(`Auth: ${CONFIG.apiKey ? 'API Key required' : 'No auth (set API_KEY env var)'}`);
+    console.log(`IP whitelist: ${CONFIG.allowedIps.length > 0 ? CONFIG.allowedIps.join(', ') : 'disabled'}`);
+    console.log(`Rate limit: ${CONFIG.rateLimitPerMinute}/min per IP`);
+    console.log(`\nEndpoints:`);
+    console.log(`  GET  /health`);
+    console.log(`  GET  /status`);
+    console.log(`  POST /send-text`);
+    console.log(`  POST /send-media`);
+    console.log(`  POST /send-reaction`);
+    console.log(`  DELETE /message`);
+    console.log(`  GET  /groups`);
+    console.log(`  GET  /groups/:jid`);
+    console.log(`  POST /groups/create`);
+    console.log(`  POST /groups/:jid/participants`);
+    console.log(`  GET  /groups/:jid/invite`);
+    console.log(`  POST /webhook`);
+    console.log(`  GET  /webhooks\n`);
+  });
+}
+
+main().catch(err => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/examples/rest-gateway/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "waliwa-rest-gateway",
+  "version": "1.0.0",
+  "description": "HTTP REST API gateway untuk kirim pesan WhatsApp via REST endpoints",
+  "main": "index.ts",
+  "scripts": {
+    "start": "ts-node index.ts"
+  },
+  "dependencies": {
+    "waliwa": "file:../../",
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@types/express": "^4.17.21",
+    "typescript": "^5.3.3",
+    "ts-node": "^10.9.2"
+  }
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@kangwifi-pro/waliwa",
+  "version": "1.0.0",
+  "description": "Lightweight, RAM-efficient WhatsApp library with hybrid protocol (WhatsApp Web MD + Mobile API), Multi-Branch SKDM Recovery system, and 9+ Baileys issue fixes. More complete than Baileys, lighter than ZapoJS.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./types": {
+      "import": "./dist/types/index.js",
+      "require": "./dist/types/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "ts-node examples/echo-bot/index.ts",
+    "lint": "eslint src --ext .ts",
+    "test": "jest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "whatsapp",
+    "bot",
+    "wa-web",
+    "multi-device",
+    "reverse-engineering",
+    "baileys",
+    "zapojs",
+    "lightweight",
+    "ram-efficient",
+    "noise-protocol",
+    "protobuf",
+    "pairing-code",
+    "qr-code"
+  ],
+  "author": "waliwa contributors",
+  "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "@noble/curves": "^1.4.0",
+    "@noble/hashes": "^1.4.0",
+    "@noble/ciphers": "^0.5.1",
+    "protobufjs": "^7.3.0",
+    "ws": "^8.16.0",
+    "qrcode-terminal": "^0.12.0",
+    "axios": "^1.6.7"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.20",
+    "@types/ws": "^8.5.10",
+    "@types/qrcode-terminal": "^0.12.2",
+    "typescript": "^5.3.3",
+    "ts-node": "^10.9.2",
+    "eslint": "^8.56.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.2",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2"
+  },
+  "peerDependenciesMeta": {
+    "openai": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    }
+  }
+}