@gakr-gakr/line 0.1.0

package/src/auto-reply-delivery.ts

@@ -0,0 +1,200 @@
+import type { messagingApi } from "@line/bot-sdk";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { resolveSendableOutboundReplyParts } from "autobot/plugin-sdk/reply-payload";
+import type { ReplyPayload } from "autobot/plugin-sdk/reply-runtime";
+import type { FlexContainer } from "./flex-templates.js";
+import type { ProcessedLineMessage } from "./markdown-to-line.js";
+import { buildLineQuickReplyFallbackText } from "./quick-reply-fallback.js";
+import type { SendLineReplyChunksParams } from "./reply-chunks.js";
+import type { LineChannelData, LineTemplateMessagePayload } from "./types.js";
+
+export type LineAutoReplyDeps = {
+  buildTemplateMessageFromPayload: (
+    payload: LineTemplateMessagePayload,
+  ) => messagingApi.TemplateMessage | null;
+  processLineMessage: (text: string) => ProcessedLineMessage;
+  chunkMarkdownText: (text: string, limit: number) => string[];
+  sendLineReplyChunks: (params: SendLineReplyChunksParams) => Promise<{ replyTokenUsed: boolean }>;
+  createQuickReplyItems: (labels: string[]) => messagingApi.QuickReply;
+  pushMessagesLine: (
+    to: string,
+    messages: messagingApi.Message[],
+    opts: { cfg: AutoBotConfig; accountId?: string },
+  ) => Promise<unknown>;
+  createFlexMessage: (altText: string, contents: FlexContainer) => messagingApi.FlexMessage;
+  createImageMessage: (
+    originalContentUrl: string,
+    previewImageUrl?: string,
+  ) => messagingApi.ImageMessage;
+  createLocationMessage: (location: {
+    title: string;
+    address: string;
+    latitude: number;
+    longitude: number;
+  }) => messagingApi.LocationMessage;
+} & Pick<
+  SendLineReplyChunksParams,
+  | "replyMessageLine"
+  | "pushMessageLine"
+  | "pushTextMessageWithQuickReplies"
+  | "createTextMessageWithQuickReplies"
+  | "onReplyError"
+>;
+
+export async function deliverLineAutoReply(params: {
+  payload: ReplyPayload;
+  lineData: LineChannelData;
+  to: string;
+  replyToken?: string | null;
+  replyTokenUsed: boolean;
+  accountId?: string;
+  cfg: AutoBotConfig;
+  textLimit: number;
+  deps: LineAutoReplyDeps;
+}): Promise<{ replyTokenUsed: boolean }> {
+  const { payload, lineData, replyToken, accountId, to, textLimit, deps } = params;
+  let replyTokenUsed = params.replyTokenUsed;
+
+  const pushLineMessages = async (messages: messagingApi.Message[]): Promise<void> => {
+    if (messages.length === 0) {
+      return;
+    }
+    for (let i = 0; i < messages.length; i += 5) {
+      await deps.pushMessagesLine(to, messages.slice(i, i + 5), {
+        cfg: params.cfg,
+        accountId,
+      });
+    }
+  };
+
+  const sendLineMessages = async (
+    messages: messagingApi.Message[],
+    allowReplyToken: boolean,
+  ): Promise<void> => {
+    if (messages.length === 0) {
+      return;
+    }
+
+    let remaining = messages;
+    if (allowReplyToken && replyToken && !replyTokenUsed) {
+      const replyBatch = remaining.slice(0, 5);
+      try {
+        await deps.replyMessageLine(replyToken, replyBatch, {
+          cfg: params.cfg,
+          accountId,
+        });
+      } catch (err) {
+        deps.onReplyError?.(err);
+        await pushLineMessages(replyBatch);
+      }
+      replyTokenUsed = true;
+      remaining = remaining.slice(replyBatch.length);
+    }
+
+    if (remaining.length > 0) {
+      await pushLineMessages(remaining);
+    }
+  };
+
+  const richMessages: messagingApi.Message[] = [];
+  const hasQuickReplies = Boolean(lineData.quickReplies?.length);
+
+  if (lineData.flexMessage) {
+    richMessages.push(
+      deps.createFlexMessage(
+        lineData.flexMessage.altText.slice(0, 400),
+        lineData.flexMessage.contents as FlexContainer,
+      ),
+    );
+  }
+
+  if (lineData.templateMessage) {
+    const templateMsg = deps.buildTemplateMessageFromPayload(lineData.templateMessage);
+    if (templateMsg) {
+      richMessages.push(templateMsg);
+    }
+  }
+
+  if (lineData.location) {
+    richMessages.push(deps.createLocationMessage(lineData.location));
+  }
+
+  const processed = payload.text
+    ? deps.processLineMessage(payload.text)
+    : { text: "", flexMessages: [] };
+
+  for (const flexMsg of processed.flexMessages) {
+    richMessages.push(deps.createFlexMessage(flexMsg.altText.slice(0, 400), flexMsg.contents));
+  }
+
+  const chunks = processed.text ? deps.chunkMarkdownText(processed.text, textLimit) : [];
+
+  const mediaUrls = resolveSendableOutboundReplyParts(payload).mediaUrls;
+  const mediaMessages = mediaUrls
+    .map((url) => url?.trim())
+    .filter((url): url is string => Boolean(url))
+    .map((url) => deps.createImageMessage(url));
+
+  if (chunks.length > 0) {
+    const hasRichOrMedia = richMessages.length > 0 || mediaMessages.length > 0;
+    if (hasQuickReplies && hasRichOrMedia) {
+      try {
+        await sendLineMessages([...richMessages, ...mediaMessages], false);
+      } catch (err) {
+        deps.onReplyError?.(err);
+      }
+    }
+    const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
+      to,
+      chunks,
+      quickReplies: lineData.quickReplies,
+      replyToken,
+      replyTokenUsed,
+      cfg: params.cfg,
+      accountId,
+      replyMessageLine: deps.replyMessageLine,
+      pushMessageLine: deps.pushMessageLine,
+      pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
+      createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
+    });
+    replyTokenUsed = nextReplyTokenUsed;
+    if (!hasQuickReplies || !hasRichOrMedia) {
+      await sendLineMessages(richMessages, false);
+      if (mediaMessages.length > 0) {
+        await sendLineMessages(mediaMessages, false);
+      }
+    }
+  } else {
+    const combined = [...richMessages, ...mediaMessages];
+    if (hasQuickReplies && combined.length === 0) {
+      const { replyTokenUsed: nextReplyTokenUsed } = await deps.sendLineReplyChunks({
+        to,
+        chunks: [buildLineQuickReplyFallbackText(lineData.quickReplies)],
+        quickReplies: lineData.quickReplies,
+        replyToken,
+        replyTokenUsed,
+        cfg: params.cfg,
+        accountId,
+        replyMessageLine: deps.replyMessageLine,
+        pushMessageLine: deps.pushMessageLine,
+        pushTextMessageWithQuickReplies: deps.pushTextMessageWithQuickReplies,
+        createTextMessageWithQuickReplies: deps.createTextMessageWithQuickReplies,
+        onReplyError: deps.onReplyError,
+      });
+      replyTokenUsed = nextReplyTokenUsed;
+    } else {
+      if (hasQuickReplies && combined.length > 0) {
+        const quickReply = deps.createQuickReplyItems(lineData.quickReplies!);
+        const targetIndex =
+          replyToken && !replyTokenUsed ? Math.min(4, combined.length - 1) : combined.length - 1;
+        const target = combined[targetIndex] as messagingApi.Message & {
+          quickReply?: messagingApi.QuickReply;
+        };
+        combined[targetIndex] = { ...target, quickReply };
+      }
+      await sendLineMessages(combined, true);
+    }
+  }
+
+  return { replyTokenUsed };
+}

package/src/bindings.ts

@@ -0,0 +1,65 @@
+function normalizeLineConversationId(raw?: string | null): string | null {
+  const trimmed = raw?.trim() ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  const prefixed = trimmed.match(/^line:(?:(?:user|group|room):)?(.+)$/i)?.[1];
+  return (prefixed ?? trimmed).trim() || null;
+}
+
+function resolveLineCommandConversation(params: {
+  originatingTo?: string;
+  commandTo?: string;
+  fallbackTo?: string;
+}) {
+  const conversationId =
+    normalizeLineConversationId(params.originatingTo) ??
+    normalizeLineConversationId(params.commandTo) ??
+    normalizeLineConversationId(params.fallbackTo);
+  return conversationId ? { conversationId } : null;
+}
+
+function resolveLineInboundConversation(params: { to?: string; conversationId?: string }) {
+  const conversationId =
+    normalizeLineConversationId(params.conversationId) ?? normalizeLineConversationId(params.to);
+  return conversationId ? { conversationId } : null;
+}
+
+export const lineBindingsAdapter = {
+  compileConfiguredBinding: ({ conversationId }: { conversationId?: string }) => {
+    const normalized = normalizeLineConversationId(conversationId);
+    return normalized ? { conversationId: normalized } : null;
+  },
+  matchInboundConversation: ({
+    compiledBinding,
+    conversationId,
+  }: {
+    compiledBinding: { conversationId: string };
+    conversationId?: string;
+  }) => {
+    const normalizedIncoming = normalizeLineConversationId(conversationId);
+    if (!normalizedIncoming || compiledBinding.conversationId !== normalizedIncoming) {
+      return null;
+    }
+    return {
+      conversationId: normalizedIncoming,
+      matchPriority: 2,
+    };
+  },
+  resolveCommandConversation: ({
+    originatingTo,
+    commandTo,
+    fallbackTo,
+  }: {
+    originatingTo?: string;
+    commandTo?: string;
+    fallbackTo?: string;
+  }) =>
+    resolveLineCommandConversation({
+      originatingTo,
+      commandTo,
+      fallbackTo,
+    }),
+  resolveInboundConversation: ({ to, conversationId }: { to?: string; conversationId?: string }) =>
+    resolveLineInboundConversation({ to, conversationId }),
+};

package/src/bot-access.ts

@@ -0,0 +1,30 @@
+import { firstDefined } from "autobot/plugin-sdk/allow-from";
+
+export type NormalizedAllowFrom = {
+  entries: string[];
+  hasWildcard: boolean;
+  hasEntries: boolean;
+};
+
+export function normalizeLineAllowEntry(value: string | number): string {
+  const trimmed = String(value).trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (trimmed === "*") {
+    return "*";
+  }
+  return trimmed.replace(/^line:(?:user:)?/i, "");
+}
+
+export const normalizeAllowFrom = (list?: Array<string | number>): NormalizedAllowFrom => {
+  const entries = (list ?? []).map((value) => normalizeLineAllowEntry(value)).filter(Boolean);
+  const hasWildcard = entries.includes("*");
+  return {
+    entries,
+    hasWildcard,
+    hasEntries: entries.length > 0,
+  };
+};
+
+export { firstDefined };