@gakr-gakr/whatsapp 0.1.0

package/src/creds-persistence.ts

@@ -0,0 +1,71 @@
+import { replaceFileAtomic } from "autobot/plugin-sdk/security-runtime";
+import { resolveWebCredsPath } from "./creds-files.js";
+
+const CREDS_FILE_MODE = 0o600;
+const CREDS_SAVE_FLUSH_TIMEOUT_MS = 15_000;
+
+const credsSaveQueues = new Map<string, Promise<void>>();
+
+export type CredsQueueWaitResult = "drained" | "timed_out";
+
+async function stringifyCreds(creds: unknown): Promise<string> {
+  const { BufferJSON } = await import("./session.runtime.js");
+  return JSON.stringify(creds, BufferJSON.replacer);
+}
+
+export async function writeCredsJsonAtomically(authDir: string, creds: unknown): Promise<void> {
+  const credsPath = resolveWebCredsPath(authDir);
+  const json = await stringifyCreds(creds);
+  await replaceFileAtomic({
+    filePath: credsPath,
+    content: json,
+    dirMode: 0o700,
+    mode: CREDS_FILE_MODE,
+    tempPrefix: ".creds",
+    syncTempFile: true,
+    syncParentDir: true,
+  });
+}
+
+export function enqueueCredsSave(
+  authDir: string,
+  saveCreds: () => Promise<void> | void,
+  onError: (error: unknown) => void,
+): void {
+  const previous = credsSaveQueues.get(authDir) ?? Promise.resolve();
+  const next = previous
+    .then(() => saveCreds())
+    .catch((error) => {
+      onError(error);
+    })
+    .finally(() => {
+      if (credsSaveQueues.get(authDir) === next) {
+        credsSaveQueues.delete(authDir);
+      }
+    });
+  credsSaveQueues.set(authDir, next);
+}
+
+export function waitForCredsSaveQueue(authDir?: string): Promise<void> {
+  if (authDir) {
+    return credsSaveQueues.get(authDir) ?? Promise.resolve();
+  }
+  return Promise.all(credsSaveQueues.values()).then(() => {});
+}
+
+export async function waitForCredsSaveQueueWithTimeout(
+  authDir: string,
+  timeoutMs = CREDS_SAVE_FLUSH_TIMEOUT_MS,
+): Promise<CredsQueueWaitResult> {
+  let flushTimeout: ReturnType<typeof setTimeout> | undefined;
+  return await Promise.race([
+    waitForCredsSaveQueue(authDir).then(() => "drained" as const),
+    new Promise<CredsQueueWaitResult>((resolve) => {
+      flushTimeout = setTimeout(() => resolve("timed_out"), timeoutMs);
+    }),
+  ]).finally(() => {
+    if (flushTimeout) {
+      clearTimeout(flushTimeout);
+    }
+  });
+}

package/src/directory-config.ts

@@ -0,0 +1,40 @@
+import {
+  listResolvedDirectoryGroupEntriesFromMapKeys,
+  listResolvedDirectoryUserEntriesFromAllowFrom,
+  type DirectoryConfigParams,
+} from "autobot/plugin-sdk/directory-config-runtime";
+import { resolveMergedWhatsAppAccountConfig } from "./account-config.js";
+import type { WhatsAppAccountConfig } from "./account-types.js";
+import { isWhatsAppGroupJid, normalizeWhatsAppTarget } from "./normalize.js";
+
+type WhatsAppDirectoryAccount = WhatsAppAccountConfig & { accountId: string };
+
+function resolveWhatsAppDirectoryAccount(
+  cfg: DirectoryConfigParams["cfg"],
+  accountId?: string | null,
+): WhatsAppDirectoryAccount {
+  return resolveMergedWhatsAppAccountConfig({ cfg, accountId });
+}
+
+export async function listWhatsAppDirectoryPeersFromConfig(params: DirectoryConfigParams) {
+  return listResolvedDirectoryUserEntriesFromAllowFrom<WhatsAppDirectoryAccount>({
+    ...params,
+    resolveAccount: resolveWhatsAppDirectoryAccount,
+    resolveAllowFrom: (account) => account.allowFrom,
+    normalizeId: (entry) => {
+      const normalized = normalizeWhatsAppTarget(entry);
+      if (!normalized || isWhatsAppGroupJid(normalized)) {
+        return null;
+      }
+      return normalized;
+    },
+  });
+}
+
+export async function listWhatsAppDirectoryGroupsFromConfig(params: DirectoryConfigParams) {
+  return listResolvedDirectoryGroupEntriesFromMapKeys<WhatsAppDirectoryAccount>({
+    ...params,
+    resolveAccount: resolveWhatsAppDirectoryAccount,
+    resolveGroups: (account) => account.groups,
+  });
+}

package/src/doctor-contract.ts

@@ -0,0 +1,11 @@
+import type { ChannelDoctorConfigMutation } from "autobot/plugin-sdk/channel-contract";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { normalizeCompatibilityConfig as normalizeCompatibilityConfigImpl } from "./doctor.js";
+
+export function normalizeCompatibilityConfig({
+  cfg,
+}: {
+  cfg: AutoBotConfig;
+}): ChannelDoctorConfigMutation {
+  return normalizeCompatibilityConfigImpl({ cfg });
+}

package/src/doctor.ts

@@ -0,0 +1,56 @@
+import type {
+  ChannelDoctorAdapter,
+  ChannelDoctorConfigMutation,
+} from "autobot/plugin-sdk/channel-contract";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+
+export function normalizeCompatibilityConfig({
+  cfg,
+}: {
+  cfg: AutoBotConfig;
+}): ChannelDoctorConfigMutation {
+  const legacyAckReaction = cfg.messages?.ackReaction?.trim();
+  if (!legacyAckReaction || cfg.channels?.whatsapp === undefined) {
+    return { config: cfg, changes: [] };
+  }
+  if (cfg.channels.whatsapp?.ackReaction !== undefined) {
+    return { config: cfg, changes: [] };
+  }
+
+  const legacyScope = cfg.messages?.ackReactionScope ?? "group-mentions";
+  let direct = true;
+  let group: "always" | "mentions" | "never" = "mentions";
+  if (legacyScope === "all") {
+    direct = true;
+    group = "always";
+  } else if (legacyScope === "direct") {
+    direct = true;
+    group = "never";
+  } else if (legacyScope === "group-all") {
+    direct = false;
+    group = "always";
+  } else if (legacyScope === "group-mentions") {
+    direct = false;
+    group = "mentions";
+  }
+
+  return {
+    config: {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        whatsapp: {
+          ...cfg.channels?.whatsapp,
+          ackReaction: { emoji: legacyAckReaction, direct, group },
+        },
+      },
+    },
+    changes: [
+      `Copied messages.ackReaction → channels.whatsapp.ackReaction (scope: ${legacyScope}).`,
+    ],
+  };
+}
+
+export const whatsappDoctor: ChannelDoctorAdapter = {
+  normalizeCompatibilityConfig,
+};

package/src/document-filename.ts

@@ -0,0 +1,17 @@
+import { extensionForMime } from "autobot/plugin-sdk/media-mime";
+
+const WHATSAPP_DEFAULT_DOCUMENT_FILE_NAME = "file";
+
+export function resolveWhatsAppDefaultDocumentFileName(mimetype?: string): string {
+  const extension = extensionForMime(mimetype);
+  return extension
+    ? `${WHATSAPP_DEFAULT_DOCUMENT_FILE_NAME}${extension}`
+    : WHATSAPP_DEFAULT_DOCUMENT_FILE_NAME;
+}
+
+export function resolveWhatsAppDocumentFileName(params: {
+  fileName?: string;
+  mimetype?: string;
+}): string {
+  return params.fileName?.trim() || resolveWhatsAppDefaultDocumentFileName(params.mimetype);
+}

package/src/group-intro.ts

@@ -0,0 +1,15 @@
+const WHATSAPP_GROUP_INTRO_HINT =
+  "WhatsApp IDs: SenderId is the participant JID (group participant id).";
+
+export function resolveWhatsAppGroupIntroHint(): string {
+  return WHATSAPP_GROUP_INTRO_HINT;
+}
+
+export function resolveWhatsAppMentionStripRegexes(ctx: { To?: string | null }): RegExp[] {
+  const selfE164 = (ctx.To ?? "").replace(/^whatsapp:/i, "");
+  if (!selfE164) {
+    return [];
+  }
+  const escaped = selfE164.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return [new RegExp(escaped, "g"), new RegExp(`@${escaped}`, "g")];
+}

package/src/group-policy.ts

@@ -0,0 +1,40 @@
+import {
+  resolveChannelGroupRequireMention,
+  resolveChannelGroupToolsPolicy,
+  type GroupToolPolicyConfig,
+} from "autobot/plugin-sdk/channel-policy";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+
+type WhatsAppGroupContext = {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  groupId?: string | null;
+  senderId?: string | null;
+  senderName?: string | null;
+  senderUsername?: string | null;
+  senderE164?: string | null;
+};
+
+export function resolveWhatsAppGroupRequireMention(params: WhatsAppGroupContext): boolean {
+  return resolveChannelGroupRequireMention({
+    cfg: params.cfg,
+    channel: "whatsapp",
+    groupId: params.groupId,
+    accountId: params.accountId,
+  });
+}
+
+export function resolveWhatsAppGroupToolPolicy(
+  params: WhatsAppGroupContext,
+): GroupToolPolicyConfig | undefined {
+  return resolveChannelGroupToolsPolicy({
+    cfg: params.cfg,
+    channel: "whatsapp",
+    groupId: params.groupId,
+    accountId: params.accountId,
+    senderId: params.senderId,
+    senderName: params.senderName,
+    senderUsername: params.senderUsername,
+    senderE164: params.senderE164,
+  });
+}

package/src/group-session-contract.ts

@@ -0,0 +1,20 @@
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+
+export function resolveLegacyGroupSessionKey(ctx: { From?: string }): {
+  key: string;
+  channel: string;
+  id: string;
+  chatType: "group";
+} | null {
+  const from = typeof ctx.From === "string" ? ctx.From.trim() : "";
+  const normalized = normalizeLowercaseStringOrEmpty(from);
+  if (!from || from.includes(":") || !normalized.endsWith("@g.us")) {
+    return null;
+  }
+  return {
+    key: `whatsapp:group:${normalized}`,
+    channel: "whatsapp",
+    id: normalized,
+    chatType: "group",
+  };
+}

package/src/group-session-key.ts

@@ -0,0 +1,42 @@
+import {
+  DEFAULT_ACCOUNT_ID,
+  normalizeAccountId,
+  resolveThreadSessionKeys,
+  type ResolvedAgentRoute,
+} from "autobot/plugin-sdk/routing";
+
+function resolveWhatsAppGroupAccountThreadId(accountId: string): string {
+  return `whatsapp-account-${normalizeAccountId(accountId)}`;
+}
+
+export function resolveWhatsAppLegacyGroupSessionKey(params: {
+  sessionKey: string;
+  accountId?: string | null;
+}): string | null {
+  const accountId = normalizeAccountId(params.accountId);
+  if (!accountId || accountId === DEFAULT_ACCOUNT_ID || !params.sessionKey.includes(":group:")) {
+    return null;
+  }
+  const suffix = `:thread:${resolveWhatsAppGroupAccountThreadId(accountId)}`;
+  return params.sessionKey.endsWith(suffix) ? params.sessionKey.slice(0, -suffix.length) : null;
+}
+
+export function resolveWhatsAppGroupSessionRoute(route: ResolvedAgentRoute): ResolvedAgentRoute {
+  if (route.accountId === DEFAULT_ACCOUNT_ID || !route.sessionKey.includes(":group:")) {
+    return route;
+  }
+  const scopedSession = resolveThreadSessionKeys({
+    baseSessionKey: route.sessionKey,
+    threadId: resolveWhatsAppGroupAccountThreadId(route.accountId),
+  });
+  return {
+    ...route,
+    sessionKey: scopedSession.sessionKey,
+  };
+}
+
+export const testing = {
+  resolveWhatsAppGroupAccountThreadId,
+  resolveWhatsAppLegacyGroupSessionKey,
+};
+export { testing as __testing };

package/src/heartbeat.ts

@@ -0,0 +1,34 @@
+import { resolveWhatsAppAccount } from "./accounts.js";
+import { readWebAuthExistsForDecision, WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store.js";
+import type { AutoBotConfig } from "./runtime-api.js";
+import { loadWhatsAppChannelRuntime } from "./shared.js";
+
+export async function checkWhatsAppHeartbeatReady(params: {
+  cfg: AutoBotConfig;
+  accountId?: string;
+  deps?: {
+    readWebAuthExistsForDecision?: typeof readWebAuthExistsForDecision;
+    hasActiveWebListener?: (accountId?: string) => boolean;
+  };
+}) {
+  if (params.cfg.web?.enabled === false) {
+    return { ok: false as const, reason: "whatsapp-disabled" as const };
+  }
+  const account = resolveWhatsAppAccount({ cfg: params.cfg, accountId: params.accountId });
+  const authState = await (
+    params.deps?.readWebAuthExistsForDecision ?? readWebAuthExistsForDecision
+  )(account.authDir);
+  if (authState.outcome === "unstable") {
+    return { ok: false as const, reason: WHATSAPP_AUTH_UNSTABLE_CODE };
+  }
+  if (!authState.exists) {
+    return { ok: false as const, reason: "whatsapp-not-linked" as const };
+  }
+  const listenerActive = params.deps?.hasActiveWebListener
+    ? params.deps.hasActiveWebListener(account.accountId)
+    : Boolean((await loadWhatsAppChannelRuntime()).getActiveWebListener(account.accountId));
+  if (!listenerActive) {
+    return { ok: false as const, reason: "whatsapp-not-running" as const };
+  }
+  return { ok: true as const, reason: "ok" as const };
+}

package/src/identity.ts

@@ -0,0 +1,164 @@
+import { jidToE164, normalizeE164 } from "./text-runtime.js";
+
+const WHATSAPP_LID_RE = /@(lid|hosted\.lid)$/i;
+
+export type WhatsAppIdentity = {
+  jid?: string | null;
+  lid?: string | null;
+  e164?: string | null;
+  name?: string | null;
+  label?: string | null;
+};
+
+export type WhatsAppSelfIdentity = {
+  jid?: string | null;
+  lid?: string | null;
+  e164?: string | null;
+};
+
+export type WhatsAppReplyContext = {
+  id?: string;
+  body: string;
+  sender?: WhatsAppIdentity | null;
+};
+
+type LegacySenderLike = {
+  sender?: WhatsAppIdentity;
+  senderJid?: string;
+  senderE164?: string;
+  senderName?: string;
+};
+
+type LegacySelfLike = {
+  self?: WhatsAppSelfIdentity;
+  selfJid?: string | null;
+  selfLid?: string | null;
+  selfE164?: string | null;
+};
+
+type LegacyReplyLike = {
+  replyTo?: WhatsAppReplyContext;
+  replyToId?: string;
+  replyToBody?: string;
+  replyToSender?: string;
+  replyToSenderJid?: string;
+  replyToSenderE164?: string;
+};
+
+type LegacyMentionsLike = {
+  mentions?: string[];
+  mentionedJids?: string[];
+};
+
+function normalizeDeviceScopedJid(jid: string | null | undefined): string | null {
+  return jid ? jid.replace(/:\d+/, "") : null;
+}
+
+function isLidJid(jid: string | null | undefined): boolean {
+  return Boolean(jid && WHATSAPP_LID_RE.test(jid));
+}
+
+export function resolveComparableIdentity(
+  identity: WhatsAppIdentity | WhatsAppSelfIdentity | null | undefined,
+  authDir?: string,
+): WhatsAppIdentity {
+  const rawJid = normalizeDeviceScopedJid(identity?.jid);
+  const rawLid = normalizeDeviceScopedJid(identity?.lid);
+  const lid = rawLid ?? (isLidJid(rawJid) ? rawJid : null);
+  const jid = rawJid && !isLidJid(rawJid) ? rawJid : null;
+  const e164 =
+    identity?.e164 != null
+      ? normalizeE164(identity.e164)
+      : ((jid ? jidToE164(jid, authDir ? { authDir } : undefined) : null) ??
+        (lid ? jidToE164(lid, authDir ? { authDir } : undefined) : null));
+  return {
+    ...identity,
+    jid,
+    lid,
+    e164,
+  };
+}
+
+export function getComparableIdentityValues(
+  identity: WhatsAppIdentity | WhatsAppSelfIdentity | null | undefined,
+): string[] {
+  const resolved = resolveComparableIdentity(identity);
+  return [resolved.e164, resolved.jid, resolved.lid].filter((value): value is string =>
+    Boolean(value),
+  );
+}
+
+export function identitiesOverlap(
+  left: WhatsAppIdentity | WhatsAppSelfIdentity | null | undefined,
+  right: WhatsAppIdentity | WhatsAppSelfIdentity | null | undefined,
+): boolean {
+  const leftValues = new Set(getComparableIdentityValues(left));
+  if (leftValues.size === 0) {
+    return false;
+  }
+  return getComparableIdentityValues(right).some((value) => leftValues.has(value));
+}
+
+export function getSenderIdentity(msg: LegacySenderLike, authDir?: string): WhatsAppIdentity {
+  return resolveComparableIdentity(
+    msg.sender ?? {
+      jid: msg.senderJid ?? null,
+      e164: msg.senderE164 ?? null,
+      name: msg.senderName ?? null,
+    },
+    authDir,
+  );
+}
+
+export function getSelfIdentity(msg: LegacySelfLike, authDir?: string): WhatsAppSelfIdentity {
+  return resolveComparableIdentity(
+    msg.self ?? {
+      jid: msg.selfJid ?? null,
+      lid: msg.selfLid ?? null,
+      e164: msg.selfE164 ?? null,
+    },
+    authDir,
+  );
+}
+
+export function getReplyContext(
+  msg: LegacyReplyLike,
+  authDir?: string,
+): WhatsAppReplyContext | null {
+  if (msg.replyTo) {
+    return {
+      ...msg.replyTo,
+      sender: resolveComparableIdentity(msg.replyTo.sender, authDir),
+    };
+  }
+  if (!msg.replyToBody) {
+    return null;
+  }
+  return {
+    id: msg.replyToId,
+    body: msg.replyToBody,
+    sender: resolveComparableIdentity(
+      {
+        jid: msg.replyToSenderJid ?? null,
+        e164: msg.replyToSenderE164 ?? null,
+        label: msg.replyToSender ?? null,
+      },
+      authDir,
+    ),
+  };
+}
+
+function getMentionJids(msg: LegacyMentionsLike): string[] {
+  return msg.mentions ?? msg.mentionedJids ?? [];
+}
+
+export function getMentionIdentities(
+  msg: LegacyMentionsLike,
+  authDir?: string,
+): WhatsAppIdentity[] {
+  return getMentionJids(msg).map((jid) => resolveComparableIdentity({ jid }, authDir));
+}
+
+export function getPrimaryIdentityId(identity: WhatsAppIdentity | null | undefined): string | null {
+  return identity?.e164 || identity?.jid?.trim() || identity?.lid || null;
+}