@gakr-gakr/whatsapp 0.1.0

package/src/accounts.ts

@@ -0,0 +1,176 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  DEFAULT_ACCOUNT_ID,
+  normalizeAccountId,
+  resolveUserPath,
+  type AutoBotConfig,
+} from "autobot/plugin-sdk/account-core";
+import type { DmPolicy, GroupPolicy, ReplyToMode } from "autobot/plugin-sdk/config-contracts";
+import { resolveOAuthDir } from "autobot/plugin-sdk/state-paths";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { resolveMergedWhatsAppAccountConfig } from "./account-config.js";
+import {
+  listConfiguredAccountIds,
+  listWhatsAppAccountIds,
+  resolveDefaultWhatsAppAccountId,
+} from "./account-ids.js";
+import type { WhatsAppAccountConfig } from "./account-types.js";
+import { hasWebCredsSync } from "./creds-files.js";
+
+export { listWhatsAppAccountIds, resolveDefaultWhatsAppAccountId } from "./account-ids.js";
+
+export type ResolvedWhatsAppAccount = {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  sendReadReceipts: boolean;
+  messagePrefix?: string;
+  defaultTo?: string;
+  authDir: string;
+  isLegacyAuthDir: boolean;
+  selfChatMode?: boolean;
+  allowFrom?: string[];
+  groupAllowFrom?: string[];
+  groupPolicy?: GroupPolicy;
+  dmPolicy?: DmPolicy;
+  historyLimit?: number;
+  textChunkLimit?: number;
+  chunkMode?: "length" | "newline";
+  mediaMaxMb?: number;
+  blockStreaming?: boolean;
+  ackReaction?: WhatsAppAccountConfig["ackReaction"];
+  reactionLevel?: WhatsAppAccountConfig["reactionLevel"];
+  groups?: WhatsAppAccountConfig["groups"];
+  direct?: WhatsAppAccountConfig["direct"];
+  debounceMs?: number;
+  replyToMode?: ReplyToMode;
+};
+
+export const DEFAULT_WHATSAPP_MEDIA_MAX_MB = 50;
+
+export function listWhatsAppAuthDirs(cfg: AutoBotConfig): string[] {
+  const oauthDir = resolveOAuthDir();
+  const whatsappDir = path.join(oauthDir, "whatsapp");
+  const authDirs = new Set<string>([oauthDir, path.join(whatsappDir, DEFAULT_ACCOUNT_ID)]);
+
+  const accountIds = listConfiguredAccountIds(cfg);
+  for (const accountId of accountIds) {
+    authDirs.add(resolveWhatsAppAuthDir({ cfg, accountId }).authDir);
+  }
+
+  try {
+    const entries = fs.readdirSync(whatsappDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      authDirs.add(path.join(whatsappDir, entry.name));
+    }
+  } catch {
+    // ignore missing dirs
+  }
+
+  return Array.from(authDirs);
+}
+
+export function hasAnyWhatsAppAuth(cfg: AutoBotConfig): boolean {
+  return listWhatsAppAuthDirs(cfg).some((authDir) => hasWebCredsSync(authDir));
+}
+
+function resolveDefaultAuthDir(accountId: string): string {
+  return path.join(resolveOAuthDir(), "whatsapp", normalizeAccountId(accountId));
+}
+
+function resolveLegacyAuthDir(): string {
+  // Legacy Baileys creds lived in the same directory as OAuth tokens.
+  return resolveOAuthDir();
+}
+
+function legacyAuthExists(authDir: string): boolean {
+  try {
+    return fs.existsSync(path.join(authDir, "creds.json"));
+  } catch {
+    return false;
+  }
+}
+
+export function resolveWhatsAppAuthDir(params: { cfg: AutoBotConfig; accountId: string }): {
+  authDir: string;
+  isLegacy: boolean;
+} {
+  const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+  const account = resolveMergedWhatsAppAccountConfig({ cfg: params.cfg, accountId });
+  const configured = account?.authDir?.trim();
+  if (configured) {
+    return { authDir: resolveUserPath(configured), isLegacy: false };
+  }
+
+  const defaultDir = resolveDefaultAuthDir(accountId);
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    const legacyDir = resolveLegacyAuthDir();
+    if (legacyAuthExists(legacyDir) && !legacyAuthExists(defaultDir)) {
+      return { authDir: legacyDir, isLegacy: true };
+    }
+  }
+
+  return { authDir: defaultDir, isLegacy: false };
+}
+
+export function resolveWhatsAppAccount(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+}): ResolvedWhatsAppAccount {
+  const merged = resolveMergedWhatsAppAccountConfig({
+    cfg: params.cfg,
+    accountId: params.accountId?.trim() || resolveDefaultWhatsAppAccountId(params.cfg),
+  });
+  const accountId = merged.accountId;
+  const enabled = merged.enabled !== false;
+  const { authDir, isLegacy } = resolveWhatsAppAuthDir({
+    cfg: params.cfg,
+    accountId,
+  });
+  return {
+    accountId,
+    name: normalizeOptionalString(merged.name),
+    enabled,
+    sendReadReceipts: merged.sendReadReceipts ?? true,
+    messagePrefix: merged.messagePrefix ?? params.cfg.messages?.messagePrefix,
+    defaultTo: merged.defaultTo,
+    authDir,
+    isLegacyAuthDir: isLegacy,
+    selfChatMode: merged.selfChatMode,
+    dmPolicy: merged.dmPolicy,
+    allowFrom: merged.allowFrom,
+    groupAllowFrom: merged.groupAllowFrom,
+    groupPolicy: merged.groupPolicy,
+    historyLimit: merged.historyLimit,
+    textChunkLimit: merged.textChunkLimit,
+    chunkMode: merged.chunkMode,
+    mediaMaxMb: merged.mediaMaxMb,
+    blockStreaming: merged.blockStreaming,
+    ackReaction: merged.ackReaction,
+    reactionLevel: merged.reactionLevel,
+    groups: merged.groups,
+    direct: merged.direct,
+    debounceMs: merged.debounceMs,
+    replyToMode: merged.replyToMode,
+  };
+}
+
+export function resolveWhatsAppMediaMaxBytes(
+  account: Pick<ResolvedWhatsAppAccount, "mediaMaxMb">,
+): number {
+  const mediaMaxMb =
+    typeof account.mediaMaxMb === "number" && account.mediaMaxMb > 0
+      ? account.mediaMaxMb
+      : DEFAULT_WHATSAPP_MEDIA_MAX_MB;
+  return mediaMaxMb * 1024 * 1024;
+}
+
+export function listEnabledWhatsAppAccounts(cfg: AutoBotConfig): ResolvedWhatsAppAccount[] {
+  return listWhatsAppAccountIds(cfg)
+    .map((accountId) => resolveWhatsAppAccount({ cfg, accountId }))
+    .filter((account) => account.enabled);
+}

package/src/action-runtime-target-auth.ts

@@ -0,0 +1,27 @@
+import { ToolAuthorizationError } from "autobot/plugin-sdk/channel-actions";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { resolveWhatsAppAccount } from "./accounts.js";
+import { resolveWhatsAppOutboundTarget } from "./resolve-outbound-target.js";
+
+export function resolveAuthorizedWhatsAppOutboundTarget(params: {
+  cfg: AutoBotConfig;
+  chatJid: string;
+  accountId?: string;
+  actionLabel: string;
+}): { to: string; accountId: string } {
+  const account = resolveWhatsAppAccount({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  const resolution = resolveWhatsAppOutboundTarget({
+    to: params.chatJid,
+    allowFrom: account.allowFrom ?? [],
+    mode: "implicit",
+  });
+  if (!resolution.ok) {
+    throw new ToolAuthorizationError(
+      `WhatsApp ${params.actionLabel} blocked: chatJid "${params.chatJid}" is not in the configured allowFrom list for account "${account.accountId}".`,
+    );
+  }
+  return { to: resolution.to, accountId: account.accountId };
+}

package/src/action-runtime.ts

@@ -0,0 +1,76 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import {
+  createActionGate,
+  jsonResult,
+  readReactionParams,
+  readStringParam,
+} from "autobot/plugin-sdk/channel-actions";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { resolveAuthorizedWhatsAppOutboundTarget } from "./action-runtime-target-auth.js";
+import { resolveWhatsAppReactionLevel } from "./reaction-level.js";
+import { sendReactionWhatsApp } from "./send.js";
+
+export const whatsAppActionRuntime = {
+  resolveAuthorizedWhatsAppOutboundTarget,
+  sendReactionWhatsApp,
+};
+
+export async function handleWhatsAppAction(
+  params: Record<string, unknown>,
+  cfg: AutoBotConfig,
+): Promise<AgentToolResult<unknown>> {
+  const action = readStringParam(params, "action", { required: true });
+  const whatsAppConfig = cfg.channels?.whatsapp;
+  const isActionEnabled = createActionGate(whatsAppConfig?.actions);
+
+  if (action === "react") {
+    const accountId = readStringParam(params, "accountId");
+    if (!whatsAppConfig) {
+      throw new Error("WhatsApp reactions are disabled.");
+    }
+    if (!isActionEnabled("reactions")) {
+      throw new Error("WhatsApp reactions are disabled.");
+    }
+    const reactionLevelInfo = resolveWhatsAppReactionLevel({
+      cfg,
+      accountId: accountId ?? undefined,
+    });
+    if (!reactionLevelInfo.agentReactionsEnabled) {
+      throw new Error(
+        `WhatsApp agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). ` +
+          `Set channels.whatsapp.reactionLevel to "minimal" or "extensive" to enable.`,
+      );
+    }
+    const chatJid = readStringParam(params, "chatJid", { required: true });
+    const messageId = readStringParam(params, "messageId", { required: true });
+    const { emoji, remove, isEmpty } = readReactionParams(params, {
+      removeErrorMessage: "Emoji is required to remove a WhatsApp reaction.",
+    });
+    const participant = readStringParam(params, "participant");
+    const fromMeRaw = params.fromMe;
+    const fromMe = typeof fromMeRaw === "boolean" ? fromMeRaw : undefined;
+
+    // Resolve account + allowFrom via shared account logic so auth and routing stay aligned.
+    const resolved = whatsAppActionRuntime.resolveAuthorizedWhatsAppOutboundTarget({
+      cfg,
+      chatJid,
+      accountId,
+      actionLabel: "reaction",
+    });
+
+    const resolvedEmoji = remove ? "" : emoji;
+    await whatsAppActionRuntime.sendReactionWhatsApp(resolved.to, messageId, resolvedEmoji, {
+      verbose: false,
+      fromMe,
+      participant: participant ?? undefined,
+      accountId: resolved.accountId,
+      cfg,
+    });
+    if (!remove && !isEmpty) {
+      return jsonResult({ ok: true, added: emoji });
+    }
+    return jsonResult({ ok: true, removed: true });
+  }
+
+  throw new Error(`Unsupported WhatsApp action: ${action}`);
+}

package/src/active-listener.ts

@@ -0,0 +1,17 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { resolveDefaultWhatsAppAccountId } from "./account-ids.js";
+import { getRegisteredWhatsAppConnectionController } from "./connection-controller-registry.js";
+import type { ActiveWebListener } from "./inbound/types.js";
+
+export type { ActiveWebListener, ActiveWebSendOptions } from "./inbound/types.js";
+
+export function resolveWebAccountId(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+}): string {
+  return (params.accountId ?? "").trim() || resolveDefaultWhatsAppAccountId(params.cfg);
+}
+
+export function getActiveWebListener(accountId: string): ActiveWebListener | null {
+  return getRegisteredWhatsAppConnectionController(accountId)?.getActiveListener() ?? null;
+}

package/src/agent-tools-login.ts

@@ -0,0 +1,113 @@
+import type { ChannelAgentTool } from "autobot/plugin-sdk/channel-contract";
+import { Type } from "typebox";
+import { startWebLoginWithQr, waitForWebLogin } from "../login-qr-api.js";
+
+const QR_DATA_URL_MAX_LENGTH = 16_384;
+
+function readOptionalString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+export function createWhatsAppLoginTool(): ChannelAgentTool {
+  return {
+    label: "WhatsApp Login",
+    name: "whatsapp_login",
+    ownerOnly: true,
+    description: "Generate a WhatsApp QR code for linking, or wait for the scan to complete.",
+    // NOTE: Using Type.Unsafe for action enum instead of Type.Union([Type.Literal(...)]
+    // because Claude API on Vertex AI rejects nested anyOf schemas as invalid JSON Schema.
+    parameters: Type.Object({
+      action: Type.Unsafe<"start" | "wait">({
+        type: "string",
+        enum: ["start", "wait"],
+      }),
+      timeoutMs: Type.Optional(Type.Number()),
+      force: Type.Optional(Type.Boolean()),
+      accountId: Type.Optional(Type.String()),
+      currentQrDataUrl: Type.Optional(
+        Type.String({
+          maxLength: QR_DATA_URL_MAX_LENGTH,
+          pattern: "^data:image/png;base64,",
+        }),
+      ),
+    }),
+    execute: async (_toolCallId, args) => {
+      const renderQrReply = (params: {
+        message: string;
+        qrDataUrl: string;
+        connected?: boolean;
+      }) => {
+        const text = [
+          params.message,
+          "",
+          "Open WhatsApp → Linked Devices and scan:",
+          "",
+          `![whatsapp-qr](${params.qrDataUrl})`,
+        ].join("\n");
+        return {
+          content: [{ type: "text" as const, text }],
+          details: {
+            connected: params.connected ?? false,
+            qr: true,
+          },
+        };
+      };
+
+      const action = (args as { action?: string })?.action ?? "start";
+      const accountId = readOptionalString((args as { accountId?: unknown }).accountId);
+      if (action === "wait") {
+        const result = await waitForWebLogin({
+          accountId,
+          timeoutMs:
+            typeof (args as { timeoutMs?: unknown }).timeoutMs === "number"
+              ? (args as { timeoutMs?: number }).timeoutMs
+              : undefined,
+          currentQrDataUrl: readOptionalString(
+            (args as { currentQrDataUrl?: unknown }).currentQrDataUrl,
+          ),
+        });
+        if (result.qrDataUrl) {
+          return renderQrReply({
+            message: result.message,
+            qrDataUrl: result.qrDataUrl,
+            connected: result.connected,
+          });
+        }
+        return {
+          content: [{ type: "text", text: result.message }],
+          details: { connected: result.connected },
+        };
+      }
+
+      const result = await startWebLoginWithQr({
+        accountId,
+        timeoutMs:
+          typeof (args as { timeoutMs?: unknown }).timeoutMs === "number"
+            ? (args as { timeoutMs?: number }).timeoutMs
+            : undefined,
+        force:
+          typeof (args as { force?: unknown }).force === "boolean"
+            ? (args as { force?: boolean }).force
+            : false,
+      });
+
+      if (!result.qrDataUrl) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.message,
+            },
+          ],
+          details: { qr: false },
+        };
+      }
+
+      return renderQrReply({
+        message: result.message,
+        qrDataUrl: result.qrDataUrl,
+        connected: result.connected,
+      });
+    },
+  };
+}

package/src/approval-auth.ts

@@ -0,0 +1,27 @@
+import {
+  createResolvedApproverActionAuthAdapter,
+  resolveApprovalApprovers,
+} from "autobot/plugin-sdk/approval-auth-runtime";
+import { resolveWhatsAppAccount } from "./accounts.js";
+import { normalizeWhatsAppTarget } from "./normalize.js";
+
+function normalizeWhatsAppApproverId(value: string | number): string | undefined {
+  const normalized = normalizeWhatsAppTarget(String(value));
+  if (!normalized || normalized.endsWith("@g.us")) {
+    return undefined;
+  }
+  return normalized;
+}
+
+export const whatsappApprovalAuth = createResolvedApproverActionAuthAdapter({
+  channelLabel: "WhatsApp",
+  resolveApprovers: ({ cfg, accountId }) => {
+    const account = resolveWhatsAppAccount({ cfg, accountId });
+    return resolveApprovalApprovers({
+      allowFrom: account.allowFrom,
+      defaultTo: account.defaultTo,
+      normalizeApprover: normalizeWhatsAppApproverId,
+    });
+  },
+  normalizeSenderId: (value) => normalizeWhatsAppApproverId(value),
+});

package/src/auth-store.runtime.ts

@@ -0,0 +1 @@
+export { resolveOAuthDir } from "autobot/plugin-sdk/state-paths";