@lofa199419/waha-v2 2.1.0

package/src/client.ts

@@ -0,0 +1,585 @@
+/**
+ * Typed wrapper over waha-node's WahaClient.
+ *
+ * waha-node uses `any` everywhere; this file provides typed entry points
+ * for the operations the plugin actually uses so the rest of the codebase
+ * stays `any`-free.
+ */
+import { WahaClient } from "waha-node";
+import type { WahaV2MessageResult, WahaV2SessionInfo } from "./types.js";
+
+export type WahaV2ClientConfig = {
+  baseUrl: string;
+  apiKey?: string;
+};
+
+export type WahaV2FilePayload = {
+  data: string; // base64
+  mimetype: string;
+  filename: string;
+};
+
+export type WahaV2PollPayload = {
+  name: string;
+  options: string[];
+  multipleAnswers?: boolean;
+};
+
+export class WahaV2Client {
+  private readonly inner: WahaClient;
+  private readonly _config: WahaV2ClientConfig;
+
+  constructor(config: WahaV2ClientConfig) {
+    this._config = config;
+    this.inner = new WahaClient(config.baseUrl, config.apiKey);
+  }
+
+  private async postPresence(
+    endpoint: "/api/startTyping" | "/api/stopTyping",
+    session: string,
+    chatId: string,
+  ): Promise<void> {
+    const url = `${this._config.baseUrl}${endpoint}`;
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (this._config.apiKey) headers["X-Api-Key"] = this._config.apiKey;
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ session, chatId }),
+    });
+    if (response.ok) {
+      return;
+    }
+    const body = await response.text().catch(() => "");
+    const suffix = body ? ` body=${body.slice(0, 240)}` : "";
+    throw new Error(`WAHA ${endpoint} failed: ${response.status} ${response.statusText}${suffix}`);
+  }
+
+  async getChatLabels(session: string, chatId: string): Promise<Array<{ id?: string; name?: string }>> {
+    const url = `${this._config.baseUrl}/api/${encodeURIComponent(session)}/labels/chats/${encodeURIComponent(chatId)}`;
+    const headers: Record<string, string> = { Accept: "application/json" };
+    if (this._config.apiKey) headers["X-Api-Key"] = this._config.apiKey;
+    const response = await fetch(url, { method: "GET", headers });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      const suffix = body ? ` body=${body.slice(0, 240)}` : "";
+      throw new Error(
+        `WAHA /labels/chats lookup failed: ${response.status} ${response.statusText}${suffix}`,
+      );
+    }
+    const json = (await response.json().catch(() => [])) as unknown;
+    if (!Array.isArray(json)) return [];
+    return json as Array<{ id?: string; name?: string }>;
+  }
+
+  async listLabels(
+    session: string,
+  ): Promise<Array<{ id?: string; name?: string; color?: number; colorHex?: string }>> {
+    const url = `${this._config.baseUrl}/api/${encodeURIComponent(session)}/labels`;
+    const headers: Record<string, string> = { Accept: "application/json" };
+    if (this._config.apiKey) headers["X-Api-Key"] = this._config.apiKey;
+    const response = await fetch(url, { method: "GET", headers });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      const suffix = body ? ` body=${body.slice(0, 240)}` : "";
+      throw new Error(`WAHA /labels lookup failed: ${response.status} ${response.statusText}${suffix}`);
+    }
+    const json = (await response.json().catch(() => [])) as unknown;
+    if (!Array.isArray(json)) return [];
+    return json as Array<{ id?: string; name?: string; color?: number; colorHex?: string }>;
+  }
+
+  async setChatLabels(session: string, chatId: string, labelIds: string[]): Promise<void> {
+    const url = `${this._config.baseUrl}/api/${encodeURIComponent(session)}/labels/chats/${encodeURIComponent(chatId)}`;
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (this._config.apiKey) headers["X-Api-Key"] = this._config.apiKey;
+    const response = await fetch(url, {
+      method: "PUT",
+      headers,
+      body: JSON.stringify({ labels: labelIds }),
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      const suffix = body ? ` body=${body.slice(0, 240)}` : "";
+      throw new Error(
+        `WAHA /labels/chats update failed: ${response.status} ${response.statusText}${suffix}`,
+      );
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Session management
+  // ---------------------------------------------------------------------------
+
+  async listSessions(all = true): Promise<WahaV2SessionInfo[]> {
+    const result = (await this.inner.sessions.list(all)) as WahaV2SessionInfo[];
+    return Array.isArray(result) ? result : [];
+  }
+
+  /**
+   * Create a session, optionally embedding webhook config at creation time.
+   * Passing webhookConfig avoids a separate update call (and its timing race).
+   */
+  async createSession(session: string, webhookConfig?: Record<string, unknown>): Promise<void> {
+    await this.inner.sessions.create(session, webhookConfig ?? null, true);
+  }
+
+  /**
+   * Update a session's configuration (e.g. to register a webhook URL).
+   * WAHA docs: PUT /api/sessions/{session} with { config: { ... } }
+   */
+  async updateSession(session: string, config: Record<string, unknown>): Promise<void> {
+    await this.inner.sessions.update(session, config);
+  }
+
+  async startSession(session: string): Promise<void> {
+    await this.inner.sessions.start(session);
+  }
+
+  async stopSession(session: string): Promise<void> {
+    await this.inner.sessions.stop(session);
+  }
+
+  async logoutSession(session: string): Promise<void> {
+    await this.inner.sessions.logout(session);
+  }
+
+  async getQr(session: string): Promise<{ data?: string }> {
+    // WAHA returns { value: "..." } for raw format; map to { data } for consistency.
+    const raw = (await this.inner.sessions.getQr(session, "raw", true)) as {
+      value?: string;
+      data?: string;
+    };
+    return { data: raw?.data ?? raw?.value };
+  }
+
+  async requestCode(session: string, phoneNumber: string): Promise<{ code?: string }> {
+    return (await this.inner.sessions.requestCode(session, phoneNumber)) as { code?: string };
+  }
+
+  // ---------------------------------------------------------------------------
+  // Messages — sending
+  // ---------------------------------------------------------------------------
+
+  async sendText(session: string, chatId: string, text: string): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.sendText(session, chatId, text)) as WahaV2MessageResult;
+  }
+
+  async sendImage(
+    session: string,
+    chatId: string,
+    file: WahaV2FilePayload,
+    caption?: string,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.sendImage(
+      session,
+      chatId,
+      file,
+      caption,
+    )) as WahaV2MessageResult;
+  }
+
+  async sendVideo(
+    session: string,
+    chatId: string,
+    file: WahaV2FilePayload,
+    caption?: string,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.sendVideo(
+      session,
+      chatId,
+      file,
+      caption,
+    )) as WahaV2MessageResult;
+  }
+
+  async sendVoice(
+    session: string,
+    chatId: string,
+    file: WahaV2FilePayload,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.sendVoice(session, chatId, file)) as WahaV2MessageResult;
+  }
+
+  async sendFile(
+    session: string,
+    chatId: string,
+    file: WahaV2FilePayload,
+    caption?: string,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.sendFile(
+      session,
+      chatId,
+      file,
+      caption,
+    )) as WahaV2MessageResult;
+  }
+
+  async sendLocation(
+    session: string,
+    chatId: string,
+    latitude: number,
+    longitude: number,
+    title?: string,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.sendLocation(
+      session,
+      chatId,
+      latitude,
+      longitude,
+      title,
+    )) as WahaV2MessageResult;
+  }
+
+  /** contacts is an array of vCard-like objects: [{ vcard: "BEGIN:VCARD..." }] or phone JIDs */
+  async sendContact(
+    session: string,
+    chatId: string,
+    contacts: unknown[],
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.sendContact(
+      session,
+      chatId,
+      contacts,
+    )) as WahaV2MessageResult;
+  }
+
+  async sendPoll(
+    session: string,
+    chatId: string,
+    poll: WahaV2PollPayload,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.sendPoll(session, chatId, poll)) as WahaV2MessageResult;
+  }
+
+  async forwardMessage(
+    session: string,
+    chatId: string,
+    messageId: string,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.messages.forwardMessage(
+      session,
+      chatId,
+      messageId,
+    )) as WahaV2MessageResult;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Messages — management
+  // ---------------------------------------------------------------------------
+
+  async addReaction(session: string, messageId: string, reaction: string): Promise<void> {
+    await this.inner.messages.addReaction(session, messageId, reaction);
+  }
+
+  async starMessage(
+    session: string,
+    chatId: string,
+    messageId: string,
+    star = true,
+  ): Promise<void> {
+    await this.inner.messages.starMessage(session, chatId, messageId, star);
+  }
+
+  async editMessage(
+    session: string,
+    chatId: string,
+    messageId: string,
+    text: string,
+  ): Promise<void> {
+    await this.inner.messages.editMessage(session, chatId, messageId, text);
+  }
+
+  async deleteMessage(session: string, chatId: string, messageId: string): Promise<void> {
+    await this.inner.messages.deleteMessage(session, chatId, messageId);
+  }
+
+  async pinMessage(session: string, chatId: string, messageId: string): Promise<void> {
+    await this.inner.messages.pinMessage(session, chatId, messageId);
+  }
+
+  async unpinMessage(session: string, chatId: string, messageId: string): Promise<void> {
+    await this.inner.messages.unpinMessage(session, chatId, messageId);
+  }
+
+  async sendSeen(session: string, chatId: string, messageIds?: string[]): Promise<void> {
+    await this.inner.messages.sendSeen(session, chatId, messageIds);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Presence / typing — not in waha-node; call REST API directly
+  // ---------------------------------------------------------------------------
+
+  /** POST /api/startTyping — shows "typing…" indicator in the chat. */
+  async startTyping(session: string, chatId: string): Promise<void> {
+    await this.postPresence("/api/startTyping", session, chatId);
+  }
+
+  /** POST /api/stopTyping — clears the typing indicator. */
+  async stopTyping(session: string, chatId: string): Promise<void> {
+    await this.postPresence("/api/stopTyping", session, chatId);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Chats
+  // ---------------------------------------------------------------------------
+
+  async listChats(session: string, limit?: number, offset?: number): Promise<unknown[]> {
+    return (await this.inner.chats.list(session, limit, offset)) as unknown[];
+  }
+
+  async getChatsOverview(session: string): Promise<unknown> {
+    return this.inner.chats.getOverview(session);
+  }
+
+  async getChatMessages(
+    session: string,
+    chatId: string,
+    limit?: number,
+    downloadMedia = false,
+  ): Promise<unknown[]> {
+    return (await this.inner.chats.getMessages(session, chatId, limit, downloadMedia)) as unknown[];
+  }
+
+  async getChatMessage(
+    session: string,
+    chatId: string,
+    messageId: string,
+    downloadMedia = false,
+  ): Promise<unknown> {
+    return this.inner.chats.getMessage(session, chatId, messageId, downloadMedia);
+  }
+
+  async readChatMessages(session: string, chatId: string, messageIds?: string[]): Promise<void> {
+    await this.inner.chats.readMessages(session, chatId, messageIds);
+  }
+
+  async archiveChat(session: string, chatId: string): Promise<void> {
+    await this.inner.chats.archive(session, chatId);
+  }
+
+  async unarchiveChat(session: string, chatId: string): Promise<void> {
+    await this.inner.chats.unarchive(session, chatId);
+  }
+
+  async deleteChat(session: string, chatId: string): Promise<void> {
+    await this.inner.chats.deleteChat(session, chatId);
+  }
+
+  async markChatUnread(session: string, chatId: string): Promise<void> {
+    await this.inner.chats.unread(session, chatId);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Contacts
+  // ---------------------------------------------------------------------------
+
+  async listContacts(session: string, limit?: number, offset?: number): Promise<unknown[]> {
+    return (await this.inner.contacts.listAll(session, limit, offset)) as unknown[];
+  }
+
+  async getContact(session: string, contactId: string): Promise<unknown> {
+    return this.inner.contacts.getContact(session, contactId);
+  }
+
+  async checkContactExists(session: string, phone: string): Promise<unknown> {
+    return this.inner.contacts.checkExists(session, phone);
+  }
+
+  async getContactAbout(session: string, contactId: string): Promise<unknown> {
+    return this.inner.contacts.getAbout(session, contactId);
+  }
+
+  async getContactProfilePicture(session: string, contactId: string): Promise<unknown> {
+    return this.inner.contacts.getProfilePicture(session, contactId);
+  }
+
+  async blockContact(session: string, chatId: string): Promise<void> {
+    await this.inner.contacts.block(session, chatId);
+  }
+
+  async unblockContact(session: string, chatId: string): Promise<void> {
+    await this.inner.contacts.unblock(session, chatId);
+  }
+
+  async updateContact(
+    session: string,
+    chatId: string,
+    firstName: string,
+    lastName: string,
+  ): Promise<unknown> {
+    return this.inner.contacts.update(session, chatId, firstName, lastName);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Groups
+  // ---------------------------------------------------------------------------
+
+  async listGroups(session: string): Promise<unknown[]> {
+    return (await this.inner.groups.list(session)) as unknown[];
+  }
+
+  async getGroup(session: string, groupId: string): Promise<unknown> {
+    return this.inner.groups.getGroup(session, groupId);
+  }
+
+  async createGroup(session: string, subject: string, participants?: string[]): Promise<unknown> {
+    return this.inner.groups.create(session, subject, participants);
+  }
+
+  async leaveGroup(session: string, groupId: string): Promise<void> {
+    await this.inner.groups.leave(session, groupId);
+  }
+
+  async getGroupParticipants(session: string, groupId: string): Promise<unknown[]> {
+    return (await this.inner.groups.getParticipants(session, groupId)) as unknown[];
+  }
+
+  async addGroupParticipants(
+    session: string,
+    groupId: string,
+    participants: string[],
+  ): Promise<unknown> {
+    return this.inner.groups.addParticipants(session, groupId, participants);
+  }
+
+  async removeGroupParticipants(
+    session: string,
+    groupId: string,
+    participants: string[],
+  ): Promise<unknown> {
+    return this.inner.groups.removeParticipants(session, groupId, participants);
+  }
+
+  async promoteGroupAdmin(
+    session: string,
+    groupId: string,
+    participants: string[],
+  ): Promise<unknown> {
+    return this.inner.groups.promoteAdmin(session, groupId, participants);
+  }
+
+  async demoteGroupAdmin(
+    session: string,
+    groupId: string,
+    participants: string[],
+  ): Promise<unknown> {
+    return this.inner.groups.demoteAdmin(session, groupId, participants);
+  }
+
+  async getGroupInviteCode(session: string, groupId: string): Promise<unknown> {
+    return this.inner.groups.getInviteCode(session, groupId);
+  }
+
+  async revokeGroupInviteCode(session: string, groupId: string): Promise<unknown> {
+    return this.inner.groups.revokeInviteCode(session, groupId);
+  }
+
+  async updateGroupSubject(session: string, groupId: string, subject: string): Promise<void> {
+    await this.inner.groups.updateSubject(session, groupId, subject);
+  }
+
+  async updateGroupDescription(
+    session: string,
+    groupId: string,
+    description: string,
+  ): Promise<void> {
+    await this.inner.groups.updateDescription(session, groupId, description);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Status / Stories
+  // ---------------------------------------------------------------------------
+
+  async sendStatusText(session: string, text: string): Promise<WahaV2MessageResult> {
+    return (await this.inner.status.sendText(session, text)) as WahaV2MessageResult;
+  }
+
+  async sendStatusImage(
+    session: string,
+    file: WahaV2FilePayload,
+    caption?: string,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.status.sendImage(session, file, caption)) as WahaV2MessageResult;
+  }
+
+  async sendStatusVideo(
+    session: string,
+    file: WahaV2FilePayload,
+    caption?: string,
+  ): Promise<WahaV2MessageResult> {
+    return (await this.inner.status.sendVideo(session, file, caption)) as WahaV2MessageResult;
+  }
+
+  async sendStatusVoice(session: string, file: WahaV2FilePayload): Promise<WahaV2MessageResult> {
+    return (await this.inner.status.sendVoice(session, file)) as WahaV2MessageResult;
+  }
+
+  async deleteStatus(session: string, messageId: string): Promise<void> {
+    await this.inner.status.deleteStatus(session, messageId);
+  }
+
+  // ---------------------------------------------------------------------------
+  // WhatsApp Channels (Newsletters)
+  // ---------------------------------------------------------------------------
+
+  async listWaChannels(session: string): Promise<unknown[]> {
+    return (await this.inner.channels.list(session)) as unknown[];
+  }
+
+  async getWaChannel(session: string, channelId: string): Promise<unknown> {
+    return this.inner.channels.getChannel(session, channelId);
+  }
+
+  async createWaChannel(session: string, name: string, description?: string): Promise<unknown> {
+    return this.inner.channels.create(session, name, description);
+  }
+
+  async deleteWaChannel(session: string, channelId: string): Promise<void> {
+    await this.inner.channels.deleteChannel(session, channelId);
+  }
+
+  async getWaChannelMessages(
+    session: string,
+    channelId: string,
+    limit?: number,
+  ): Promise<unknown[]> {
+    return (await this.inner.channels.getMessages(session, channelId, limit)) as unknown[];
+  }
+
+  /**
+   * Download media from a WAHA media URL, authenticating with the API key.
+   * WAHA media URLs are internal to the WAHA server and require the API key header.
+   */
+  async downloadMediaBuffer(url: string): Promise<{ buffer: Buffer; contentType: string }> {
+    const { default: https } = await import("node:https");
+    const { default: http } = await import("node:http");
+    return new Promise((resolve, reject) => {
+      const mod = url.startsWith("https") ? https : http;
+      const apiKey = this._config.apiKey;
+      const req = mod.get(url, { headers: apiKey ? { "X-Api-Key": apiKey } : {} }, (res) => {
+        if (res.statusCode && res.statusCode >= 400) {
+          reject(new Error(`WAHA media download failed: ${res.statusCode}`));
+          return;
+        }
+        const chunks: Buffer[] = [];
+        res.on("data", (c: Buffer) => chunks.push(c));
+        res.on("end", () => {
+          resolve({
+            buffer: Buffer.concat(chunks),
+            contentType: String(res.headers["content-type"] ?? "application/octet-stream"),
+          });
+        });
+      });
+      req.on("error", reject);
+      req.setTimeout(30_000, () => {
+        req.destroy();
+        reject(new Error("WAHA media download timed out"));
+      });
+    });
+  }
+}
+
+export function createWahaV2Client(config: WahaV2ClientConfig): WahaV2Client {
+  return new WahaV2Client(config);
+}