@gakr-gakr/whatsapp 0.1.0

package/src/auto-reply/monitor/status-reaction.ts

@@ -0,0 +1,108 @@
+import {
+  createStatusReactionController,
+  shouldAckReactionForWhatsApp,
+  type StatusReactionController,
+} from "autobot/plugin-sdk/channel-feedback";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import { getSenderIdentity } from "../../identity.js";
+import { resolveWhatsAppReactionLevel } from "../../reaction-level.js";
+import { sendReactionWhatsApp } from "../../send.js";
+import type { WebInboundMsg } from "../types.js";
+import { resolveGroupActivationFor } from "./group-activation.js";
+
+export type { StatusReactionController };
+
+export type WhatsAppStatusReactionParams = {
+  cfg: AutoBotConfig;
+  msg: WebInboundMsg;
+  agentId: string;
+  sessionKey: string;
+  conversationId: string;
+  verbose: boolean;
+  accountId?: string;
+};
+
+export async function createWhatsAppStatusReactionController(
+  params: WhatsAppStatusReactionParams,
+): Promise<StatusReactionController | null> {
+  if (!params.msg.id) {
+    return null;
+  }
+
+  const statusReactionsConfig = params.cfg.messages?.statusReactions;
+  if (statusReactionsConfig?.enabled !== true) {
+    return null;
+  }
+
+  const reactionLevel = resolveWhatsAppReactionLevel({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  if (reactionLevel.level === "off") {
+    return null;
+  }
+
+  const ackConfig = params.cfg.channels?.whatsapp?.ackReaction;
+  const ackEmoji = (ackConfig?.emoji ?? "").trim();
+  if (!ackEmoji) {
+    return null;
+  }
+  const directEnabled = ackConfig?.direct ?? true;
+  const groupMode = ackConfig?.group ?? "mentions";
+  const conversationIdForCheck = params.msg.conversationId ?? params.msg.from;
+
+  const activation =
+    params.msg.chatType === "group"
+      ? await resolveGroupActivationFor({
+          cfg: params.cfg,
+          accountId: params.accountId,
+          agentId: params.agentId,
+          sessionKey: params.sessionKey,
+          conversationId: conversationIdForCheck,
+        })
+      : null;
+
+  const shouldUseStatusReaction = shouldAckReactionForWhatsApp({
+    emoji: ackEmoji,
+    isDirect: params.msg.chatType === "direct",
+    isGroup: params.msg.chatType === "group",
+    directEnabled,
+    groupMode,
+    wasMentioned: params.msg.wasMentioned === true,
+    groupActivated: activation === "always",
+  });
+
+  if (!shouldUseStatusReaction) {
+    return null;
+  }
+
+  const sender = getSenderIdentity(params.msg);
+  const reactionOptions = {
+    verbose: params.verbose,
+    fromMe: false,
+    ...(sender.jid ? { participant: sender.jid } : {}),
+    ...(params.accountId ? { accountId: params.accountId } : {}),
+    cfg: params.cfg,
+  };
+  const chatId = params.msg.chatId;
+  const msgId = params.msg.id;
+
+  return createStatusReactionController({
+    enabled: true,
+    adapter: {
+      setReaction: async (emoji: string) => {
+        await sendReactionWhatsApp(chatId, msgId, emoji, reactionOptions);
+      },
+      clearReaction: async () => {
+        await sendReactionWhatsApp(chatId, msgId, "", reactionOptions);
+      },
+    },
+    initialEmoji: ackEmoji,
+    emojis: statusReactionsConfig.emojis,
+    timing: statusReactionsConfig.timing,
+    onError: (err) => {
+      logVerbose(`WhatsApp status-reaction error for chat ${chatId}/${msgId}: ${String(err)}`);
+    },
+  });
+}

package/src/auto-reply/monitor-state.ts

@@ -0,0 +1,114 @@
+import {
+  createConnectedChannelStatusPatch,
+  createTransportActivityStatusPatch,
+} from "autobot/plugin-sdk/gateway-runtime";
+import type { WebChannelHealthState, WebChannelStatus } from "./types.js";
+
+function cloneStatus(status: WebChannelStatus): WebChannelStatus {
+  return {
+    ...status,
+    lastDisconnect: status.lastDisconnect ? { ...status.lastDisconnect } : null,
+  };
+}
+
+function isTerminalHealthState(healthState: WebChannelHealthState | undefined): boolean {
+  return healthState === "conflict" || healthState === "logged-out" || healthState === "stopped";
+}
+
+export function createWebChannelStatusController(statusSink?: (status: WebChannelStatus) => void) {
+  let lastDisconnectWasWatchdogRecovery = false;
+  const status: WebChannelStatus = {
+    running: true,
+    connected: false,
+    reconnectAttempts: 0,
+    lastConnectedAt: null,
+    lastDisconnect: null,
+    lastInboundAt: null,
+    lastMessageAt: null,
+    lastEventAt: null,
+    lastError: null,
+    healthState: "starting",
+  };
+
+  const emit = () => {
+    statusSink?.(cloneStatus(status));
+  };
+
+  return {
+    emit,
+    snapshot: () => status,
+    noteConnected(at = Date.now()) {
+      Object.assign(status, createConnectedChannelStatusPatch(at));
+      Object.assign(status, createTransportActivityStatusPatch(at));
+      if (lastDisconnectWasWatchdogRecovery) {
+        status.lastDisconnect = null;
+        status.reconnectAttempts = 0;
+        lastDisconnectWasWatchdogRecovery = false;
+      }
+      status.lastError = null;
+      status.healthState = "healthy";
+      emit();
+    },
+    noteInbound(at = Date.now()) {
+      status.lastInboundAt = at;
+      status.lastMessageAt = at;
+      status.lastEventAt = at;
+      Object.assign(status, createTransportActivityStatusPatch(at));
+      if (status.connected) {
+        status.healthState = "healthy";
+      }
+      emit();
+    },
+    noteTransportActivity(at = Date.now()) {
+      if (status.lastTransportActivityAt === at) {
+        return;
+      }
+      Object.assign(status, createTransportActivityStatusPatch(at));
+      emit();
+    },
+    noteWatchdogStale(at = Date.now()) {
+      status.lastEventAt = at;
+      if (status.connected) {
+        status.healthState = "stale";
+      }
+      emit();
+    },
+    noteReconnectAttempts(reconnectAttempts: number) {
+      status.reconnectAttempts = reconnectAttempts;
+      emit();
+    },
+    noteClose(params: {
+      at?: number;
+      statusCode?: number;
+      loggedOut?: boolean;
+      error?: string;
+      reconnectAttempts: number;
+      healthState: WebChannelHealthState;
+      watchdogRecovery?: boolean;
+    }) {
+      const at = params.at ?? Date.now();
+      lastDisconnectWasWatchdogRecovery = params.watchdogRecovery === true;
+      status.connected = false;
+      status.lastEventAt = at;
+      status.lastDisconnect = {
+        at,
+        status: params.statusCode,
+        error: params.error,
+        loggedOut: Boolean(params.loggedOut),
+      };
+      status.lastError = params.error ?? null;
+      status.reconnectAttempts = params.reconnectAttempts;
+      status.healthState = params.healthState;
+      emit();
+    },
+    markStopped(at = Date.now()) {
+      status.running = false;
+      status.connected = false;
+      status.lastEventAt = at;
+      if (!isTerminalHealthState(status.healthState)) {
+        status.healthState = "stopped";
+      }
+      emit();
+    },
+  };
+}