@kodelyth/line 2026.5.42 → 2026.6.1

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

@@ -1,253 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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 };