@gakr-gakr/whatsapp 0.1.0

package/src/quoted-message.ts

@@ -0,0 +1,184 @@
+import type { MiscMessageGenerationOptions } from "baileys";
+import { jidToE164 } from "./text-runtime.js";
+
+// ── Inbound message metadata cache ──────────────────────────────────────
+// Maps messageId → { participant, participantE164, body, fromMe } so the
+// outbound adapter can
+// populate the quote key with the sender JID and preview text even though
+// the outbound path only receives a bare messageId string.
+
+type QuotedMeta = {
+  participant?: string;
+  participantE164?: string;
+  body?: string;
+  fromMe?: boolean;
+};
+type CacheEntry = QuotedMeta & { ts: number };
+type QuotedMetaLookup = QuotedMeta & { remoteJid: string };
+
+const CACHE_TTL_MS = 10 * 60 * 1000;
+const MAX_ENTRIES = 500;
+const cache = new Map<string, CacheEntry>();
+
+function makeCacheKey(accountId: string, remoteJid: string, messageId: string): string {
+  return `${accountId}:${remoteJid}:${messageId}`;
+}
+
+export function cacheInboundMessageMeta(
+  accountId: string,
+  remoteJid: string,
+  messageId: string,
+  meta: QuotedMeta,
+): void {
+  if (!accountId || !messageId || !remoteJid) {
+    return;
+  }
+  if (cache.size >= MAX_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest) {
+      cache.delete(oldest);
+    }
+  }
+  cache.set(makeCacheKey(accountId, remoteJid, messageId), { ...meta, ts: Date.now() });
+}
+
+export function lookupInboundMessageMeta(
+  accountId: string,
+  remoteJid: string,
+  messageId: string,
+): QuotedMeta | undefined {
+  const cacheKey = makeCacheKey(accountId, remoteJid, messageId);
+  const entry = cache.get(cacheKey);
+  if (!entry) {
+    return undefined;
+  }
+  if (Date.now() - entry.ts > CACHE_TTL_MS) {
+    cache.delete(cacheKey);
+    return undefined;
+  }
+  return {
+    participant: entry.participant,
+    participantE164: entry.participantE164,
+    body: entry.body,
+    fromMe: entry.fromMe,
+  };
+}
+
+function normalizeComparableJid(jid: string | undefined): string | undefined {
+  const normalized = jid?.trim().replace(/:\d+/, "").toLowerCase();
+  return normalized || undefined;
+}
+
+function isGroupJid(jid: string | undefined): boolean {
+  return Boolean(jid && jid.endsWith("@g.us"));
+}
+
+function areComparableE164sEqual(left: string | undefined, right: string | undefined): boolean {
+  const normalizedLeft = left?.trim();
+  const normalizedRight = right?.trim();
+  if (!normalizedLeft || !normalizedRight) {
+    return false;
+  }
+  return normalizedLeft === normalizedRight;
+}
+
+function areComparableJidsEqual(left: string | undefined, right: string | undefined): boolean {
+  const normalizedLeft = normalizeComparableJid(left);
+  const normalizedRight = normalizeComparableJid(right);
+  if (!normalizedLeft || !normalizedRight) {
+    return false;
+  }
+  if (normalizedLeft === normalizedRight) {
+    return true;
+  }
+  const leftE164 = jidToE164(normalizedLeft);
+  const rightE164 = jidToE164(normalizedRight);
+  return Boolean(leftE164 && rightE164 && leftE164 === rightE164);
+}
+
+function matchesQuotedConversationTarget(targetJid: string, candidate: QuotedMetaLookup): boolean {
+  if (areComparableJidsEqual(targetJid, candidate.remoteJid)) {
+    return true;
+  }
+  if (isGroupJid(targetJid) || isGroupJid(candidate.remoteJid)) {
+    return false;
+  }
+  return (
+    areComparableJidsEqual(targetJid, candidate.participant) ||
+    areComparableE164sEqual(jidToE164(targetJid) ?? undefined, candidate.participantE164)
+  );
+}
+
+export function lookupInboundMessageMetaForTarget(
+  accountId: string,
+  targetJid: string,
+  messageId: string,
+): QuotedMetaLookup | undefined {
+  if (!accountId || !messageId || !targetJid) {
+    return undefined;
+  }
+  const exact = lookupInboundMessageMeta(accountId, targetJid, messageId);
+  if (exact) {
+    return {
+      remoteJid: targetJid,
+      participant: exact.participant,
+      participantE164: exact.participantE164,
+      body: exact.body,
+      fromMe: exact.fromMe,
+    };
+  }
+  const prefix = `${accountId}:`;
+  const suffix = `:${messageId}`;
+  let matched: QuotedMetaLookup | undefined;
+  for (const [cacheKey, entry] of cache.entries()) {
+    if (!cacheKey.startsWith(prefix) || !cacheKey.endsWith(suffix)) {
+      continue;
+    }
+    if (Date.now() - entry.ts > CACHE_TTL_MS) {
+      cache.delete(cacheKey);
+      continue;
+    }
+    const remoteJid = cacheKey.slice(prefix.length, cacheKey.length - suffix.length);
+    const candidate = {
+      remoteJid,
+      participant: entry.participant,
+      participantE164: entry.participantE164,
+      body: entry.body,
+      fromMe: entry.fromMe,
+    };
+    if (!matchesQuotedConversationTarget(targetJid, candidate)) {
+      continue;
+    }
+    if (matched) {
+      return undefined;
+    }
+    matched = candidate;
+  }
+  return matched;
+}
+
+export function buildQuotedMessageOptions(params: {
+  messageId?: string | null;
+  remoteJid?: string | null;
+  fromMe?: boolean;
+  participant?: string;
+  /** Original message text — shown in the quote preview bubble. */
+  messageText?: string;
+}): MiscMessageGenerationOptions | undefined {
+  const id = params.messageId?.trim();
+  const remoteJid = params.remoteJid?.trim();
+  if (!id || !remoteJid) {
+    return undefined;
+  }
+  return {
+    quoted: {
+      key: {
+        remoteJid,
+        id,
+        fromMe: params.fromMe ?? false,
+        participant: params.participant,
+      },
+      message: { conversation: params.messageText ?? "" },
+    },
+  } as MiscMessageGenerationOptions;
+}

package/src/reaction-level.ts

@@ -0,0 +1,24 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import {
+  resolveReactionLevel,
+  type ResolvedReactionLevel,
+} from "autobot/plugin-sdk/status-helpers";
+import { resolveMergedWhatsAppAccountConfig } from "./account-config.js";
+
+type ResolvedWhatsAppReactionLevel = ResolvedReactionLevel;
+
+/** Resolve the effective reaction level and its implications for WhatsApp. */
+export function resolveWhatsAppReactionLevel(params: {
+  cfg: AutoBotConfig;
+  accountId?: string;
+}): ResolvedWhatsAppReactionLevel {
+  const account = resolveMergedWhatsAppAccountConfig({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  return resolveReactionLevel({
+    value: account.reactionLevel,
+    defaultLevel: "minimal",
+    invalidFallback: "minimal",
+  });
+}

package/src/reconnect.ts

@@ -0,0 +1,55 @@
+import { randomUUID } from "node:crypto";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import {
+  computeBackoff,
+  sleepWithAbort,
+  type BackoffPolicy,
+} from "autobot/plugin-sdk/runtime-env";
+import { clamp } from "autobot/plugin-sdk/text-utility-runtime";
+
+export type ReconnectPolicy = BackoffPolicy & {
+  maxAttempts: number;
+};
+
+export const DEFAULT_HEARTBEAT_SECONDS = 60;
+export const DEFAULT_RECONNECT_POLICY: ReconnectPolicy = {
+  initialMs: 2_000,
+  maxMs: 30_000,
+  factor: 1.8,
+  jitter: 0.25,
+  maxAttempts: 12,
+};
+
+export function resolveHeartbeatSeconds(cfg: AutoBotConfig, overrideSeconds?: number): number {
+  const candidate = overrideSeconds ?? cfg.web?.heartbeatSeconds;
+  if (typeof candidate === "number" && candidate > 0) {
+    return candidate;
+  }
+  return DEFAULT_HEARTBEAT_SECONDS;
+}
+
+export function resolveReconnectPolicy(
+  cfg: AutoBotConfig,
+  overrides?: Partial<ReconnectPolicy>,
+): ReconnectPolicy {
+  const reconnectOverrides = cfg.web?.reconnect ?? {};
+  const overrideConfig = overrides ?? {};
+  const merged = {
+    ...DEFAULT_RECONNECT_POLICY,
+    ...reconnectOverrides,
+    ...overrideConfig,
+  } as ReconnectPolicy;
+
+  merged.initialMs = Math.max(250, merged.initialMs);
+  merged.maxMs = Math.max(merged.initialMs, merged.maxMs);
+  merged.factor = clamp(merged.factor, 1.1, 10);
+  merged.jitter = clamp(merged.jitter, 0, 1);
+  merged.maxAttempts = Math.max(0, Math.floor(merged.maxAttempts));
+  return merged;
+}
+
+export { computeBackoff, sleepWithAbort };
+
+export function newConnectionId() {
+  return randomUUID();
+}

package/src/resolve-outbound-target.ts

@@ -0,0 +1,58 @@
+import { missingTargetError } from "autobot/plugin-sdk/channel-feedback";
+import {
+  isWhatsAppGroupJid,
+  isWhatsAppNewsletterJid,
+  normalizeWhatsAppTarget,
+} from "./normalize-target.js";
+
+export type WhatsAppOutboundTargetResolution =
+  | { ok: true; to: string }
+  | { ok: false; error: Error };
+
+function whatsappAllowFromPolicyError(target: string): Error {
+  return new Error(`Target "${target}" is not listed in the configured WhatsApp allowFrom policy.`);
+}
+
+export function resolveWhatsAppOutboundTarget(params: {
+  to: string | null | undefined;
+  allowFrom: Array<string | number> | null | undefined;
+  mode: string | null | undefined;
+}): WhatsAppOutboundTargetResolution {
+  const trimmed = params.to?.trim() ?? "";
+  if (!trimmed) {
+    return {
+      ok: false,
+      error: missingTargetError("WhatsApp", "<E.164|group JID|newsletter JID>"),
+    };
+  }
+
+  const normalizedTo = normalizeWhatsAppTarget(trimmed);
+  if (!normalizedTo) {
+    return {
+      ok: false,
+      error: missingTargetError("WhatsApp", "<E.164|group JID|newsletter JID>"),
+    };
+  }
+  if (isWhatsAppGroupJid(normalizedTo) || isWhatsAppNewsletterJid(normalizedTo)) {
+    return { ok: true, to: normalizedTo };
+  }
+
+  const allowListRaw = (params.allowFrom ?? [])
+    .map((entry) => String(entry).trim())
+    .filter(Boolean);
+  const hasWildcard = allowListRaw.includes("*");
+  const allowList = allowListRaw
+    .filter((entry) => entry !== "*")
+    .map((entry) => normalizeWhatsAppTarget(entry))
+    .filter((entry): entry is string => Boolean(entry));
+  if (hasWildcard || allowList.length === 0) {
+    return { ok: true, to: normalizedTo };
+  }
+  if (allowList.includes(normalizedTo)) {
+    return { ok: true, to: normalizedTo };
+  }
+  return {
+    ok: false,
+    error: whatsappAllowFromPolicyError(normalizedTo),
+  };
+}

package/src/runtime-api.ts

@@ -0,0 +1,59 @@
+export { getChatChannelMeta, type ChannelPlugin } from "autobot/plugin-sdk/core";
+export { buildChannelConfigSchema, WhatsAppConfigSchema } from "../config-api.js";
+export { DEFAULT_ACCOUNT_ID } from "autobot/plugin-sdk/account-id";
+export {
+  formatWhatsAppConfigAllowFromEntries,
+  resolveWhatsAppConfigAllowFrom,
+  resolveWhatsAppConfigDefaultTo,
+} from "./config-accessors.js";
+export {
+  createActionGate,
+  jsonResult,
+  readReactionParams,
+  readStringParam,
+  ToolAuthorizationError,
+} from "autobot/plugin-sdk/channel-actions";
+export { normalizeE164 } from "autobot/plugin-sdk/account-resolution";
+export type { DmPolicy, GroupPolicy } from "autobot/plugin-sdk/config-contracts";
+import type { AutoBotConfig as RuntimeAutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+
+export { type ChannelMessageActionName } from "autobot/plugin-sdk/channel-contract";
+export { loadOutboundMediaFromUrl } from "./outbound-media.runtime.js";
+export {
+  resolveWhatsAppGroupRequireMention,
+  resolveWhatsAppGroupToolPolicy,
+} from "./group-policy.js";
+export {
+  resolveWhatsAppGroupIntroHint,
+  resolveWhatsAppMentionStripRegexes,
+} from "./group-intro.js";
+export { createWhatsAppOutboundBase } from "./outbound-base.js";
+export {
+  isWhatsAppGroupJid,
+  isWhatsAppUserTarget,
+  looksLikeWhatsAppTargetId,
+  normalizeWhatsAppAllowFromEntries,
+  normalizeWhatsAppMessagingTarget,
+  normalizeWhatsAppTarget,
+} from "./normalize-target.js";
+export { resolveWhatsAppOutboundTarget } from "./resolve-outbound-target.js";
+export { resolveWhatsAppReactionLevel } from "./reaction-level.js";
+
+export type AutoBotConfig = RuntimeAutoBotConfig;
+export type { WhatsAppAccountConfig } from "./account-types.js";
+
+type MonitorWebChannel = typeof import("./channel.runtime.js").monitorWebChannel;
+
+let channelRuntimePromise: Promise<typeof import("./channel.runtime.js")> | null = null;
+
+function loadChannelRuntime() {
+  channelRuntimePromise ??= import("./channel.runtime.js");
+  return channelRuntimePromise;
+}
+
+export async function monitorWebChannel(
+  ...args: Parameters<MonitorWebChannel>
+): ReturnType<MonitorWebChannel> {
+  const { monitorWebChannel } = await loadChannelRuntime();
+  return await monitorWebChannel(...args);
+}

package/src/runtime-group-policy.ts

@@ -0,0 +1,16 @@
+import { resolveOpenProviderRuntimeGroupPolicy } from "autobot/plugin-sdk/runtime-group-policy";
+
+export function resolveWhatsAppRuntimeGroupPolicy(params: {
+  providerConfigPresent: boolean;
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  defaultGroupPolicy?: "open" | "allowlist" | "disabled";
+}): {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  providerMissingFallbackApplied: boolean;
+} {
+  return resolveOpenProviderRuntimeGroupPolicy({
+    providerConfigPresent: params.providerConfigPresent,
+    groupPolicy: params.groupPolicy,
+    defaultGroupPolicy: params.defaultGroupPolicy,
+  });
+}

package/src/runtime.ts

@@ -0,0 +1,9 @@
+import type { PluginRuntime } from "autobot/plugin-sdk/core";
+import { createPluginRuntimeStore } from "autobot/plugin-sdk/runtime-store";
+
+const { setRuntime: setWhatsAppRuntime, getRuntime: getWhatsAppRuntime } =
+  createPluginRuntimeStore<PluginRuntime>({
+    pluginId: "whatsapp",
+    errorMessage: "WhatsApp runtime not initialized",
+  });
+export { getWhatsAppRuntime, setWhatsAppRuntime };

package/src/security-contract.ts

@@ -0,0 +1,47 @@
+import { isRecord } from "autobot/plugin-sdk/string-coerce-runtime";
+
+type UnsupportedSecretRefConfigCandidate = {
+  path: string;
+  value: unknown;
+};
+
+export const unsupportedSecretRefSurfacePatterns = [
+  "channels.whatsapp.creds.json",
+  "channels.whatsapp.accounts.*.creds.json",
+] as const;
+
+export function collectUnsupportedSecretRefConfigCandidates(
+  raw: unknown,
+): UnsupportedSecretRefConfigCandidate[] {
+  if (!isRecord(raw)) {
+    return [];
+  }
+  if (!isRecord(raw.channels) || !isRecord(raw.channels.whatsapp)) {
+    return [];
+  }
+
+  const candidates: UnsupportedSecretRefConfigCandidate[] = [];
+  const whatsapp = raw.channels.whatsapp;
+  const creds = isRecord(whatsapp.creds) ? whatsapp.creds : null;
+  if (creds) {
+    candidates.push({
+      path: "channels.whatsapp.creds.json",
+      value: creds.json,
+    });
+  }
+
+  const accounts = isRecord(whatsapp.accounts) ? whatsapp.accounts : null;
+  if (!accounts) {
+    return candidates;
+  }
+  for (const [accountId, account] of Object.entries(accounts)) {
+    if (!isRecord(account) || !isRecord(account.creds)) {
+      continue;
+    }
+    candidates.push({
+      path: `channels.whatsapp.accounts.${accountId}.creds.json`,
+      value: account.creds.json,
+    });
+  }
+  return candidates;
+}

package/src/security-fix.ts

@@ -0,0 +1,71 @@
+import { DEFAULT_ACCOUNT_ID } from "autobot/plugin-sdk/account-id";
+import type { ChannelDoctorConfigMutation } from "autobot/plugin-sdk/channel-contract";
+import { readChannelAllowFromStore } from "autobot/plugin-sdk/channel-pairing";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+
+function applyGroupAllowFromFromStore(params: {
+  cfg: AutoBotConfig;
+  storeAllowFrom: string[];
+  changes: string[];
+}): AutoBotConfig {
+  const next = structuredClone(params.cfg ?? {});
+  const section = next.channels?.whatsapp as Record<string, unknown> | undefined;
+  if (!section || typeof section !== "object" || params.storeAllowFrom.length === 0) {
+    return params.cfg;
+  }
+
+  let changed = false;
+  const maybeApply = (prefix: string, holder: Record<string, unknown>) => {
+    if (holder.groupPolicy !== "allowlist") {
+      return;
+    }
+    const allowFrom = Array.isArray(holder.allowFrom) ? holder.allowFrom : [];
+    const groupAllowFrom = Array.isArray(holder.groupAllowFrom) ? holder.groupAllowFrom : [];
+    if (allowFrom.length > 0 || groupAllowFrom.length > 0) {
+      return;
+    }
+    holder.groupAllowFrom = params.storeAllowFrom;
+    params.changes.push(`${prefix}groupAllowFrom=pairing-store`);
+    changed = true;
+  };
+
+  maybeApply("channels.whatsapp.", section);
+
+  const accounts = section.accounts;
+  if (accounts && typeof accounts === "object") {
+    for (const [accountId, accountValue] of Object.entries(accounts)) {
+      if (!accountValue || typeof accountValue !== "object") {
+        continue;
+      }
+      maybeApply(
+        `channels.whatsapp.accounts.${accountId}.`,
+        accountValue as Record<string, unknown>,
+      );
+    }
+  }
+
+  return changed ? next : params.cfg;
+}
+
+export async function applyWhatsAppSecurityConfigFixes(params: {
+  cfg: AutoBotConfig;
+  env: NodeJS.ProcessEnv;
+}): Promise<ChannelDoctorConfigMutation> {
+  const fromStore = await readChannelAllowFromStore(
+    "whatsapp",
+    params.env,
+    DEFAULT_ACCOUNT_ID,
+  ).catch(() => []);
+  const normalized = Array.from(new Set(fromStore.map((entry) => entry.trim()))).filter(Boolean);
+  if (normalized.length === 0) {
+    return { config: params.cfg, changes: [] };
+  }
+
+  const changes: string[] = [];
+  const config = applyGroupAllowFromFromStore({
+    cfg: params.cfg,
+    storeAllowFrom: normalized,
+    changes,
+  });
+  return { config, changes };
+}