@orchestero/codex-gateway 0.0.3

package/lib/zalo-adapter.ts

@@ -0,0 +1,836 @@
+import { timingSafeEqual } from "node:crypto";
+import type {
+  Adapter,
+  AdapterPostableMessage,
+  Attachment,
+  ChatInstance,
+  FetchResult,
+  FormattedContent,
+  Logger,
+  RawMessage,
+  StreamChunk,
+  StreamOptions,
+  ThreadInfo,
+  WebhookOptions,
+} from "chat";
+import {
+  ConsoleLogger,
+  Message,
+  markdownToPlainText,
+  parseMarkdown,
+  toPlainText,
+} from "chat";
+
+type ZaloAdapterConfig = {
+  botToken: string;
+  logger?: Logger;
+  longPolling?: ZaloLongPollingConfig;
+  mode?: ZaloAdapterMode;
+  secretToken?: string;
+  userName?: string;
+};
+
+type ZaloAdapterMode = "auto" | "webhook" | "polling";
+
+type ZaloLongPollingConfig = {
+  deleteWebhook?: boolean;
+  retryDelayMs?: number;
+  timeout?: number;
+};
+
+type ResolvedZaloLongPollingConfig = {
+  deleteWebhook: boolean;
+  retryDelayMs: number;
+  timeout: number;
+};
+
+type ZaloThreadId = {
+  chatId: string;
+};
+
+type ZaloChatType = "GROUP" | "PRIVATE";
+
+type ZaloInboundMessage = {
+  caption?: string;
+  chat: {
+    chat_type: ZaloChatType;
+    id: string;
+  };
+  date: number;
+  from: {
+    display_name: string;
+    id: string;
+    is_bot: boolean;
+  };
+  message_id: string;
+  photo?: string;
+  photo_url?: string;
+  sticker?: string;
+  text?: string;
+};
+
+type ZaloWebhookPayload = {
+  event_name: string;
+  message?: ZaloInboundMessage;
+  update_id?: number;
+};
+
+type ZaloRawMessage = {
+  message: ZaloInboundMessage;
+};
+
+type ZaloGetMeResponse = {
+  account_name?: string;
+  display_name?: string;
+  id: string;
+};
+
+type ZaloSendResponse = {
+  date?: number;
+  message_id?: number | string;
+};
+
+type ZaloWebhookInfoResponse = {
+  url?: string;
+};
+
+type ZaloApiResponse<T> = {
+  description?: string;
+  error_code?: number;
+  ok: boolean;
+  result?: T;
+};
+
+class ZaloApiResponseError extends Error {
+  constructor(
+    readonly method: string,
+    readonly code: number | "unknown",
+    description: string,
+  ) {
+    super(`Zalo API error in ${method} (${code}): ${description}`);
+  }
+}
+
+const apiBaseUrl = "https://bot-api.zaloplatforms.com";
+const defaultPollingRetryDelayMs = 1000;
+const maxPollingBackoffMs = 30_000;
+const messageLimit = 2000;
+const defaultPollingTimeoutSeconds = 30;
+const secretTokenHeader = "x-bot-api-secret-token";
+
+function sleep(delayMs: number, signal: AbortSignal) {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(resolve, delayMs);
+    signal.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timeout);
+        resolve(undefined);
+      },
+      { once: true },
+    );
+  });
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function getRecord(value: unknown, key: string) {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const nextValue = value[key];
+  if (!isRecord(nextValue)) {
+    return undefined;
+  }
+
+  return nextValue;
+}
+
+function getString(value: unknown, key: string) {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const nextValue = value[key];
+  if (typeof nextValue !== "string") {
+    return undefined;
+  }
+
+  return nextValue;
+}
+
+function getStringId(value: unknown, key: string) {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const nextValue = value[key];
+  if (typeof nextValue === "string") {
+    return nextValue;
+  }
+
+  if (typeof nextValue === "number" && Number.isFinite(nextValue)) {
+    return String(nextValue);
+  }
+}
+
+function formatId(value: number | string | undefined) {
+  return value === undefined ? "" : String(value);
+}
+
+function getNumber(value: unknown, key: string) {
+  if (!isRecord(value)) {
+    return undefined;
+  }
+
+  const nextValue = value[key];
+  if (typeof nextValue !== "number") {
+    return undefined;
+  }
+
+  return nextValue;
+}
+
+function splitMessage(text: string): [string, ...string[]] {
+  if (text.length <= messageLimit) {
+    return [text];
+  }
+
+  const chunks: [string, ...string[]] = [text.slice(0, messageLimit)];
+  let startIndex = messageLimit;
+
+  while (startIndex < text.length) {
+    chunks.push(text.slice(startIndex, startIndex + messageLimit));
+    startIndex += messageLimit;
+  }
+
+  return chunks;
+}
+
+function parseInboundMessage(value: unknown): ZaloInboundMessage | undefined {
+  const chat = getRecord(value, "chat");
+  const from = getRecord(value, "from");
+  const chatType = getString(chat, "chat_type");
+  const chatId = getStringId(chat, "id");
+  const date = getNumber(value, "date");
+  const displayName = getString(from, "display_name");
+  const fromId = getStringId(from, "id");
+  const isBot = isRecord(from) ? from.is_bot : undefined;
+  const messageId = getStringId(value, "message_id");
+
+  if (
+    (chatType !== "GROUP" && chatType !== "PRIVATE") ||
+    !chatId ||
+    typeof date !== "number" ||
+    !displayName ||
+    !fromId ||
+    typeof isBot !== "boolean" ||
+    !messageId
+  ) {
+    return undefined;
+  }
+
+  return {
+    caption: getString(value, "caption"),
+    chat: {
+      chat_type: chatType,
+      id: chatId,
+    },
+    date,
+    from: {
+      display_name: displayName,
+      id: fromId,
+      is_bot: isBot,
+    },
+    message_id: messageId,
+    photo: getString(value, "photo"),
+    photo_url: getString(value, "photo_url"),
+    sticker: getString(value, "sticker"),
+    text: getString(value, "text"),
+  };
+}
+
+function parsePayload(value: unknown): ZaloWebhookPayload | undefined {
+  const payload = getRecord(value, "result") || value;
+  const eventName = getString(payload, "event_name");
+  const updateId = getNumber(payload, "update_id");
+  if (!eventName) {
+    if (typeof updateId === "number") {
+      return { event_name: "unknown", update_id: updateId };
+    }
+
+    return undefined;
+  }
+
+  return {
+    event_name: eventName,
+    message: parseInboundMessage(getRecord(payload, "message")),
+    update_id: updateId,
+  };
+}
+
+function getPayloads(value: unknown) {
+  if (Array.isArray(value)) {
+    return value
+      .map(parsePayload)
+      .filter((payload): payload is ZaloWebhookPayload => Boolean(payload));
+  }
+
+  const payload = parsePayload(value);
+  return payload ? [payload] : [];
+}
+
+function isPollingTimeout(error: unknown) {
+  return isZaloApiResponseError(error, "getUpdates", 408);
+}
+
+function isZaloApiResponseError(error: unknown, method: string, code: number) {
+  return (
+    error instanceof ZaloApiResponseError &&
+    error.method === method &&
+    error.code === code
+  );
+}
+
+function clampInteger(
+  value: number | undefined,
+  fallback: number,
+  minimum = 1,
+) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+
+  return Math.max(minimum, Math.trunc(value));
+}
+
+function isLikelyServerlessRuntime() {
+  return Boolean(
+    process.env.VERCEL ||
+      process.env.AWS_LAMBDA_FUNCTION_NAME ||
+      process.env.AWS_EXECUTION_ENV?.includes("AWS_Lambda") ||
+      process.env.FUNCTIONS_WORKER_RUNTIME ||
+      process.env.NETLIFY ||
+      process.env.K_SERVICE,
+  );
+}
+
+function renderPostableMessage(message: AdapterPostableMessage) {
+  if (typeof message === "string") {
+    return message;
+  }
+
+  if ("raw" in message) {
+    return message.raw;
+  }
+
+  if ("markdown" in message) {
+    return markdownToPlainText(message.markdown);
+  }
+
+  if ("ast" in message) {
+    return toPlainText(message.ast);
+  }
+
+  throw new Error("Zalo does not support this message type.");
+}
+
+function createZaloAdapter(
+  config: ZaloAdapterConfig,
+): Adapter<ZaloThreadId, ZaloRawMessage> {
+  const logger = config.logger ?? new ConsoleLogger("info").child("zalo");
+  const mode = config.mode ?? "auto";
+  if (mode !== "auto" && mode !== "polling" && mode !== "webhook") {
+    throw new Error(
+      `Invalid Zalo mode: ${mode}. Expected "auto", "polling", or "webhook".`,
+    );
+  }
+
+  const userName = config.userName?.trim() || "bot";
+  let botUserId: string | undefined;
+  let chat: ChatInstance | undefined;
+  let pollingAbortController: AbortController | undefined;
+  let pollingActive = false;
+  let pollingTask: Promise<void> | undefined;
+  let warnedNoWebhookVerification = false;
+
+  async function apiRequest<T>(
+    method: string,
+    body?: unknown,
+    options?: { signal?: AbortSignal },
+  ) {
+    const response = await fetch(
+      `${apiBaseUrl}/bot${config.botToken}/${method}`,
+      {
+        body: body === undefined ? undefined : JSON.stringify(body),
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+        signal: options?.signal,
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `Zalo API error in ${method}: ${response.status} ${await response.text()}`,
+      );
+    }
+
+    const data = (await response.json()) as ZaloApiResponse<T>;
+    if (!data.ok) {
+      throw new ZaloApiResponseError(
+        method,
+        data.error_code ?? "unknown",
+        data.description ?? "unknown error",
+      );
+    }
+
+    return data.result;
+  }
+
+  function encodeThreadId(threadId: ZaloThreadId) {
+    return `zalo:${threadId.chatId}`;
+  }
+
+  function decodeThreadId(threadId: string) {
+    if (!threadId.startsWith("zalo:")) {
+      throw new Error(`Invalid Zalo thread ID: ${threadId}`);
+    }
+
+    const chatId = threadId.slice(5);
+    if (!chatId) {
+      throw new Error(`Invalid Zalo thread ID format: ${threadId}`);
+    }
+
+    return { chatId };
+  }
+
+  function parseMessage(raw: ZaloRawMessage) {
+    const { message } = raw;
+    const attachments: Attachment[] = [];
+    const photoURL = message.photo_url || message.photo;
+    const text =
+      message.text || message.caption || (photoURL ? "[Image]" : "[Sticker]");
+
+    if (photoURL) {
+      attachments.push({ type: "image", url: photoURL });
+    }
+
+    return new Message<ZaloRawMessage>({
+      attachments,
+      author: {
+        fullName: message.from.display_name,
+        isBot: message.from.is_bot,
+        isMe: message.from.id === botUserId,
+        userId: message.from.id,
+        userName: message.from.display_name,
+      },
+      formatted: parseMarkdown(text),
+      id: message.message_id,
+      metadata: {
+        dateSent: new Date(message.date),
+        edited: false,
+      },
+      raw,
+      text,
+      threadId: encodeThreadId({ chatId: message.chat.id }),
+    });
+  }
+
+  function processPayload(
+    payload: ZaloWebhookPayload,
+    options?: WebhookOptions,
+  ) {
+    if (!chat || !payload.message) {
+      logger.debug("Ignored Zalo event.", { eventName: payload.event_name });
+      return;
+    }
+
+    if (
+      payload.event_name !== "message.text.received" &&
+      payload.event_name !== "message.image.received" &&
+      payload.event_name !== "message.sticker.received"
+    ) {
+      logger.debug("Ignored unsupported Zalo event.", {
+        eventName: payload.event_name,
+        messageId: payload.message.message_id,
+      });
+      return;
+    }
+
+    const threadId = encodeThreadId({ chatId: payload.message.chat.id });
+    chat.processMessage(
+      adapter,
+      threadId,
+      parseMessage({ message: payload.message }),
+      options,
+    );
+  }
+
+  function verifySecretToken(request: Request) {
+    const token = request.headers.get(secretTokenHeader);
+    if (!token || !config.secretToken) {
+      return false;
+    }
+
+    try {
+      return timingSafeEqual(
+        Buffer.from(token),
+        Buffer.from(config.secretToken),
+      );
+    } catch {
+      return false;
+    }
+  }
+
+  async function deleteWebhook() {
+    try {
+      await apiRequest("deleteWebhook");
+    } catch (error) {
+      if (isZaloApiResponseError(error, "deleteWebhook", 400)) {
+        logger.debug(
+          "Zalo webhook reset skipped because no webhook is configured.",
+        );
+        return;
+      }
+
+      throw error;
+    }
+
+    logger.info("Zalo webhook reset.");
+  }
+
+  async function fetchWebhookInfo() {
+    try {
+      return await apiRequest<ZaloWebhookInfoResponse>("getWebhookInfo");
+    } catch (error) {
+      if (isZaloApiResponseError(error, "getWebhookInfo", 404)) {
+        logger.debug(
+          "Zalo webhook info not found; assuming no webhook is configured.",
+        );
+        return {};
+      }
+
+      logger.warn("Failed to fetch Zalo webhook info.", {
+        error: String(error),
+      });
+    }
+  }
+
+  async function resolveRuntimeMode() {
+    if (mode === "webhook") {
+      return "webhook";
+    }
+
+    if (mode === "polling") {
+      return "polling";
+    }
+
+    const webhookInfo = await fetchWebhookInfo();
+    if (!webhookInfo) {
+      logger.warn(
+        "Zalo auto mode could not verify webhook status; keeping webhook mode.",
+      );
+      return "webhook";
+    }
+
+    if (typeof webhookInfo.url === "string" && webhookInfo.url.trim()) {
+      logger.debug("Zalo auto mode selected webhook mode.", {
+        webhookUrl: webhookInfo.url,
+      });
+      return "webhook";
+    }
+
+    if (isLikelyServerlessRuntime()) {
+      logger.warn(
+        "Zalo auto mode detected serverless runtime without webhook URL; keeping webhook mode.",
+      );
+      return "webhook";
+    }
+
+    logger.info("Zalo auto mode selected polling mode.");
+    return "polling";
+  }
+
+  function resolvePollingConfig(
+    override?: ZaloLongPollingConfig,
+  ): ResolvedZaloLongPollingConfig {
+    const merged = { ...config.longPolling, ...override };
+    return {
+      deleteWebhook: merged.deleteWebhook ?? true,
+      retryDelayMs: clampInteger(
+        merged.retryDelayMs,
+        defaultPollingRetryDelayMs,
+      ),
+      timeout: clampInteger(merged.timeout, defaultPollingTimeoutSeconds),
+    };
+  }
+
+  async function sendMessage(
+    threadId: string,
+    chatId: string,
+    text: string,
+  ): Promise<RawMessage<ZaloRawMessage>> {
+    const response = await apiRequest<ZaloSendResponse>("sendMessage", {
+      chat_id: chatId,
+      text,
+    });
+
+    return {
+      id: formatId(response?.message_id),
+      raw: {
+        message: {
+          chat: { chat_type: "PRIVATE", id: chatId },
+          date: response?.date ?? Date.now(),
+          from: {
+            display_name: userName,
+            id: botUserId || "",
+            is_bot: true,
+          },
+          message_id: formatId(response?.message_id),
+          text,
+        },
+      },
+      threadId,
+    };
+  }
+
+  async function sendMessages(threadId: string, chatId: string, text: string) {
+    const [firstChunk, ...remainingChunks] = splitMessage(text);
+    let message = await sendMessage(threadId, chatId, firstChunk);
+
+    for (const chunk of remainingChunks) {
+      message = await sendMessage(threadId, chatId, chunk);
+    }
+
+    return message;
+  }
+
+  async function pollingLoop(config: ResolvedZaloLongPollingConfig) {
+    let offset: number | undefined;
+    let consecutiveFailures = 0;
+
+    while (pollingActive) {
+      pollingAbortController = new AbortController();
+
+      try {
+        const body =
+          typeof offset === "number"
+            ? { offset, timeout: String(config.timeout) }
+            : { timeout: String(config.timeout) };
+        const result = await apiRequest<unknown>("getUpdates", body, {
+          signal: pollingAbortController.signal,
+        });
+        consecutiveFailures = 0;
+
+        for (const payload of getPayloads(result)) {
+          if (typeof payload.update_id === "number") {
+            const nextOffset = payload.update_id + 1;
+            offset =
+              typeof offset === "number"
+                ? Math.max(offset, nextOffset)
+                : nextOffset;
+          }
+
+          try {
+            processPayload(payload);
+          } catch (error) {
+            logger.warn("Failed to process Zalo polled update.", {
+              error: String(error),
+              updateId: payload.update_id,
+            });
+          }
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          return;
+        }
+
+        if (isPollingTimeout(error)) {
+          consecutiveFailures = 0;
+          continue;
+        }
+
+        consecutiveFailures += 1;
+        const retryDelayMs = Math.min(
+          config.retryDelayMs * 2 ** (consecutiveFailures - 1),
+          maxPollingBackoffMs,
+        );
+        logger.warn("Zalo polling request failed.", {
+          consecutiveFailures,
+          error: String(error),
+          retryDelayMs,
+        });
+
+        if (!pollingActive) {
+          return;
+        }
+
+        await sleep(retryDelayMs, pollingAbortController.signal);
+      } finally {
+        pollingAbortController = undefined;
+      }
+    }
+  }
+
+  async function startPolling(config?: ZaloLongPollingConfig) {
+    if (pollingActive) {
+      logger.debug("Zalo polling already active.");
+      return;
+    }
+
+    const resolvedConfig = resolvePollingConfig(config);
+    pollingActive = true;
+    try {
+      if (resolvedConfig.deleteWebhook) {
+        await deleteWebhook();
+      }
+    } catch (error) {
+      pollingActive = false;
+      throw error;
+    }
+
+    logger.info("Zalo polling started.", { timeout: resolvedConfig.timeout });
+    pollingTask = pollingLoop(resolvedConfig).finally(() => {
+      pollingAbortController = undefined;
+      pollingActive = false;
+      pollingTask = undefined;
+    });
+  }
+
+  async function stopPolling() {
+    if (!pollingActive) {
+      return;
+    }
+
+    pollingActive = false;
+    pollingAbortController?.abort();
+    await pollingTask;
+    logger.info("Zalo polling stopped.");
+  }
+
+  const adapter: Adapter<ZaloThreadId, ZaloRawMessage> = {
+    addReaction: async () => {
+      throw new Error("Zalo does not support reactions.");
+    },
+    get botUserId() {
+      return botUserId;
+    },
+    channelIdFromThreadId: (threadId) => threadId,
+    decodeThreadId,
+    deleteMessage: async () => {
+      throw new Error("Zalo does not support deleting messages.");
+    },
+    disconnect: stopPolling,
+    editMessage: async () => {
+      throw new Error("Zalo does not support editing messages.");
+    },
+    encodeThreadId,
+    fetchMessages: async (): Promise<FetchResult<ZaloRawMessage>> => ({
+      messages: [],
+    }),
+    fetchThread: async (threadId): Promise<ThreadInfo> => ({
+      channelId: threadId,
+      channelName: `Zalo: ${decodeThreadId(threadId).chatId}`,
+      id: threadId,
+      isDM: true,
+      metadata: { chatId: decodeThreadId(threadId).chatId },
+    }),
+    handleWebhook: async (request, options) => {
+      if (config.secretToken && !verifySecretToken(request)) {
+        logger.warn("Zalo webhook rejected due to invalid secret token.");
+        return new Response("Unauthorized", { status: 401 });
+      }
+
+      if (!config.secretToken && !warnedNoWebhookVerification) {
+        warnedNoWebhookVerification = true;
+        logger.warn(
+          "Zalo webhook verification is disabled. Set secretToken to verify incoming requests.",
+        );
+      }
+
+      let payload: ZaloWebhookPayload | undefined;
+      try {
+        payload = parsePayload(await request.json());
+      } catch {
+        return new Response("Invalid JSON", { status: 400 });
+      }
+
+      if (payload) {
+        try {
+          processPayload(payload, options);
+        } catch (error) {
+          logger.warn("Failed to process Zalo webhook update.", {
+            error: String(error),
+            eventName: payload.event_name,
+            updateId: payload.update_id,
+          });
+        }
+      }
+
+      return new Response("OK", { status: 200 });
+    },
+    initialize: async (chatInstance) => {
+      chat = chatInstance;
+      const me = await apiRequest<ZaloGetMeResponse>("getMe");
+      botUserId = me?.id;
+      logger.info("Zalo adapter initialized.", {
+        accountName: me?.account_name,
+        botUserId,
+      });
+
+      const runtimeMode = await resolveRuntimeMode();
+      if (runtimeMode === "polling") {
+        const pollingConfig =
+          mode === "auto"
+            ? { ...config.longPolling, deleteWebhook: false }
+            : config.longPolling;
+        await startPolling(pollingConfig);
+      }
+    },
+    isDM: () => true,
+    name: "zalo",
+    openDM: async (userId) => encodeThreadId({ chatId: userId }),
+    parseMessage,
+    persistThreadHistory: true,
+    postMessage: async (threadId, message) => {
+      const { chatId } = decodeThreadId(threadId);
+      return sendMessages(threadId, chatId, renderPostableMessage(message));
+    },
+    removeReaction: async () => {
+      throw new Error("Zalo does not support reactions.");
+    },
+    renderFormatted: (content: FormattedContent) => toPlainText(content),
+    startTyping: async (threadId) => {
+      const { chatId } = decodeThreadId(threadId);
+      await apiRequest("sendChatAction", {
+        action: "typing",
+        chat_id: chatId,
+      });
+    },
+    stream: async (
+      threadId,
+      textStream: AsyncIterable<string | StreamChunk>,
+      _options?: StreamOptions,
+    ): Promise<RawMessage<ZaloRawMessage>> => {
+      let accumulated = "";
+
+      for await (const chunk of textStream) {
+        if (typeof chunk === "string") {
+          accumulated += chunk;
+        } else if (chunk.type === "markdown_text") {
+          accumulated += chunk.text;
+        }
+      }
+
+      return adapter.postMessage(threadId, { markdown: accumulated });
+    },
+    userName,
+  };
+
+  return adapter;
+}
+
+export { createZaloAdapter };