@kodelyth/line 2026.5.39 → 2026.5.42

package/src/actions.ts

@@ -0,0 +1,61 @@
+import type { messagingApi } from "@line/bot-sdk";
+
+export type Action = messagingApi.Action;
+
+/**
+ * Create a message action (sends text when tapped)
+ */
+export function messageAction(label: string, text?: string): Action {
+  return {
+    type: "message",
+    label: label.slice(0, 20),
+    text: text ?? label,
+  };
+}
+
+/**
+ * Create a URI action (opens a URL when tapped)
+ */
+export function uriAction(label: string, uri: string): Action {
+  return {
+    type: "uri",
+    label: label.slice(0, 20),
+    uri,
+  };
+}
+
+/**
+ * Create a postback action (sends data to webhook when tapped)
+ */
+export function postbackAction(label: string, data: string, displayText?: string): Action {
+  return {
+    type: "postback",
+    label: label.slice(0, 20),
+    data: data.slice(0, 300),
+    displayText: displayText?.slice(0, 300),
+  };
+}
+
+/**
+ * Create a datetime picker action
+ */
+export function datetimePickerAction(
+  label: string,
+  data: string,
+  mode: "date" | "time" | "datetime",
+  options?: {
+    initial?: string;
+    max?: string;
+    min?: string;
+  },
+): Action {
+  return {
+    type: "datetimepicker",
+    label: label.slice(0, 20),
+    data: data.slice(0, 300),
+    mode,
+    initial: options?.initial,
+    max: options?.max,
+    min: options?.min,
+  };
+}

package/src/auto-reply-delivery.test.ts

@@ -0,0 +1,253 @@
+import { describe, expect, it, vi } from "vitest";
+import type { LineAutoReplyDeps } from "./auto-reply-delivery.js";
+import { deliverLineAutoReply } from "./auto-reply-delivery.js";
+import { sendLineReplyChunks } from "./reply-chunks.js";
+import { createLineSendReceipt } from "./send-receipt.js";
+
+const createFlexMessage = (altText: string, contents: unknown) => ({
+  type: "flex" as const,
+  altText,
+  contents,
+});
+
+const createImageMessage = (url: string) => ({
+  type: "image" as const,
+  originalContentUrl: url,
+  previewImageUrl: url,
+});
+
+const createLocationMessage = (location: {
+  title: string;
+  address: string;
+  latitude: number;
+  longitude: number;
+}) => ({
+  type: "location" as const,
+  ...location,
+});
+
+describe("deliverLineAutoReply", () => {
+  const LINE_TEST_CFG = { channels: { line: { accounts: { acc: {} } } } };
+  const baseDeliveryParams = {
+    cfg: LINE_TEST_CFG,
+    to: "line:user:1",
+    replyToken: "token",
+    replyTokenUsed: false,
+    accountId: "acc",
+    textLimit: 5000,
+  };
+
+  function createDeps(overrides?: Partial<LineAutoReplyDeps>) {
+    const replyMessageLine = vi.fn(async () => ({}));
+    const pushMessageLine = vi.fn(async () => ({}));
+    const pushTextMessageWithQuickReplies = vi.fn(async () => ({}));
+    const createTextMessageWithQuickReplies = vi.fn((text: string) => ({
+      type: "text" as const,
+      text,
+    }));
+    const createQuickReplyItems = vi.fn((labels: string[]) => ({ items: labels }));
+    const pushMessagesLine = vi.fn(async () => ({
+      messageId: "push",
+      chatId: "u1",
+      receipt: createLineSendReceipt({ messageId: "push", chatId: "u1", kind: "text" }),
+    }));
+
+    const deps: LineAutoReplyDeps = {
+      buildTemplateMessageFromPayload: () => null,
+      processLineMessage: (text) => ({ text, flexMessages: [] }),
+      chunkMarkdownText: (text) => [text],
+      sendLineReplyChunks,
+      replyMessageLine,
+      pushMessageLine,
+      pushTextMessageWithQuickReplies,
+      createTextMessageWithQuickReplies,
+      createQuickReplyItems: createQuickReplyItems as LineAutoReplyDeps["createQuickReplyItems"],
+      pushMessagesLine,
+      createFlexMessage: createFlexMessage as LineAutoReplyDeps["createFlexMessage"],
+      createImageMessage,
+      createLocationMessage,
+      ...overrides,
+    };
+
+    return {
+      deps,
+      replyMessageLine,
+      pushMessageLine,
+      pushTextMessageWithQuickReplies,
+      createTextMessageWithQuickReplies,
+      createQuickReplyItems,
+      pushMessagesLine,
+    };
+  }
+
+  it("uses reply token for text before sending rich messages", async () => {
+    const lineData = {
+      flexMessage: { altText: "Card", contents: { type: "bubble" } },
+    };
+    const { deps, replyMessageLine, pushMessagesLine, createQuickReplyItems } = createDeps();
+
+    const result = await deliverLineAutoReply({
+      ...baseDeliveryParams,
+      payload: { text: "hello", channelData: { line: lineData } },
+      lineData,
+      deps,
+    });
+
+    expect(result.replyTokenUsed).toBe(true);
+    expect(replyMessageLine).toHaveBeenCalledTimes(1);
+    expect(replyMessageLine).toHaveBeenCalledWith("token", [{ type: "text", text: "hello" }], {
+      cfg: LINE_TEST_CFG,
+      accountId: "acc",
+    });
+    expect(pushMessagesLine).toHaveBeenCalledTimes(1);
+    expect(pushMessagesLine).toHaveBeenCalledWith(
+      "line:user:1",
+      [createFlexMessage("Card", { type: "bubble" })],
+      { cfg: LINE_TEST_CFG, accountId: "acc" },
+    );
+    expect(createQuickReplyItems).not.toHaveBeenCalled();
+  });
+
+  it("uses reply token for rich-only payloads", async () => {
+    const lineData = {
+      flexMessage: { altText: "Card", contents: { type: "bubble" } },
+      quickReplies: ["A"],
+    };
+    const { deps, replyMessageLine, pushMessagesLine, createQuickReplyItems } = createDeps({
+      processLineMessage: () => ({ text: "", flexMessages: [] }),
+      chunkMarkdownText: () => [],
+      sendLineReplyChunks: vi.fn(async () => ({ replyTokenUsed: false })),
+    });
+
+    const result = await deliverLineAutoReply({
+      ...baseDeliveryParams,
+      payload: { channelData: { line: lineData } },
+      lineData,
+      deps,
+    });
+
+    expect(result.replyTokenUsed).toBe(true);
+    expect(replyMessageLine).toHaveBeenCalledTimes(1);
+    expect(replyMessageLine).toHaveBeenCalledWith(
+      "token",
+      [
+        {
+          ...createFlexMessage("Card", { type: "bubble" }),
+          quickReply: { items: ["A"] },
+        },
+      ],
+      { cfg: LINE_TEST_CFG, accountId: "acc" },
+    );
+    expect(pushMessagesLine).not.toHaveBeenCalled();
+    expect(createQuickReplyItems).toHaveBeenCalledWith(["A"]);
+  });
+
+  it("uses fallback text for quick-reply-only payloads", async () => {
+    const createTextMessageWithQuickReplies = vi.fn((text: string, _quickReplies: string[]) => ({
+      type: "text" as const,
+      text,
+      quickReply: { items: ["A", "B"] },
+    }));
+    const lineData = {
+      quickReplies: ["A", "B"],
+    };
+    const { deps, replyMessageLine, pushMessagesLine } = createDeps({
+      createTextMessageWithQuickReplies:
+        createTextMessageWithQuickReplies as LineAutoReplyDeps["createTextMessageWithQuickReplies"],
+    });
+
+    const result = await deliverLineAutoReply({
+      ...baseDeliveryParams,
+      payload: { text: "", channelData: { line: lineData } },
+      lineData,
+      deps,
+    });
+
+    expect(result.replyTokenUsed).toBe(true);
+    expect(replyMessageLine).toHaveBeenCalledWith(
+      "token",
+      [
+        {
+          type: "text",
+          text: "Options:\n- A\n- B",
+          quickReply: { items: ["A", "B"] },
+        },
+      ],
+      { cfg: LINE_TEST_CFG, accountId: "acc" },
+    );
+    expect(pushMessagesLine).not.toHaveBeenCalled();
+  });
+
+  it("sends rich messages before quick-reply text so quick replies remain visible", async () => {
+    const createTextMessageWithQuickReplies = vi.fn((text: string, _quickReplies: string[]) => ({
+      type: "text" as const,
+      text,
+      quickReply: { items: ["A"] },
+    }));
+
+    const lineData = {
+      flexMessage: { altText: "Card", contents: { type: "bubble" } },
+      quickReplies: ["A"],
+    };
+    const { deps, pushMessagesLine, replyMessageLine } = createDeps({
+      createTextMessageWithQuickReplies:
+        createTextMessageWithQuickReplies as LineAutoReplyDeps["createTextMessageWithQuickReplies"],
+    });
+
+    await deliverLineAutoReply({
+      ...baseDeliveryParams,
+      payload: { text: "hello", channelData: { line: lineData } },
+      lineData,
+      deps,
+    });
+
+    expect(pushMessagesLine).toHaveBeenCalledWith(
+      "line:user:1",
+      [createFlexMessage("Card", { type: "bubble" })],
+      { cfg: LINE_TEST_CFG, accountId: "acc" },
+    );
+    expect(replyMessageLine).toHaveBeenCalledWith(
+      "token",
+      [
+        {
+          type: "text",
+          text: "hello",
+          quickReply: { items: ["A"] },
+        },
+      ],
+      { cfg: LINE_TEST_CFG, accountId: "acc" },
+    );
+    const pushOrder = pushMessagesLine.mock.invocationCallOrder[0];
+    const replyOrder = replyMessageLine.mock.invocationCallOrder[0];
+    expect(pushOrder).toBeLessThan(replyOrder);
+  });
+
+  it("falls back to push when reply token delivery fails", async () => {
+    const lineData = {
+      flexMessage: { altText: "Card", contents: { type: "bubble" } },
+    };
+    const failingReplyMessageLine = vi.fn(async () => {
+      throw new Error("reply failed");
+    });
+    const { deps, pushMessagesLine } = createDeps({
+      processLineMessage: () => ({ text: "", flexMessages: [] }),
+      chunkMarkdownText: () => [],
+      replyMessageLine: failingReplyMessageLine as LineAutoReplyDeps["replyMessageLine"],
+    });
+
+    const result = await deliverLineAutoReply({
+      ...baseDeliveryParams,
+      payload: { channelData: { line: lineData } },
+      lineData,
+      deps,
+    });
+
+    expect(result.replyTokenUsed).toBe(true);
+    expect(failingReplyMessageLine).toHaveBeenCalledTimes(1);
+    expect(pushMessagesLine).toHaveBeenCalledWith(
+      "line:user:1",
+      [createFlexMessage("Card", { type: "bubble" })],
+      { cfg: LINE_TEST_CFG, accountId: "acc" },
+    );
+  });
+});

package/src/auto-reply-delivery.ts

@@ -0,0 +1,200 @@
+import type { messagingApi } from "@line/bot-sdk";
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { resolveSendableOutboundReplyParts } from "klaw/plugin-sdk/reply-payload";
+import type { ReplyPayload } from "klaw/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: KlawConfig; 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: KlawConfig;
+  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 "klaw/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 };