@gakr-gakr/line 0.1.0

package/src/bot-message-context.ts

@@ -0,0 +1,586 @@
+import type { webhook } from "@line/bot-sdk";
+import { recordChannelActivity } from "autobot/plugin-sdk/channel-activity-runtime";
+import {
+  formatInboundEnvelope,
+  formatLocationText,
+  resolveInboundSessionEnvelopeContext,
+  toLocationContext,
+} from "autobot/plugin-sdk/channel-inbound";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import {
+  ensureConfiguredBindingRouteReady,
+  resolvePinnedMainDmOwnerFromAllowlist,
+  resolveConfiguredBindingRoute,
+  resolveRuntimeConversationBindingRoute,
+} from "autobot/plugin-sdk/conversation-runtime";
+import { finalizeInboundContext } from "autobot/plugin-sdk/reply-dispatch-runtime";
+import { createChannelHistoryWindow, type HistoryEntry } from "autobot/plugin-sdk/reply-history";
+import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "autobot/plugin-sdk/routing";
+import { logVerbose, shouldLogVerbose } from "autobot/plugin-sdk/runtime-env";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { normalizeAllowFrom } from "./bot-access.js";
+import { resolveLineGroupConfigEntry } from "./group-keys.js";
+import type { ResolvedLineAccount } from "./types.js";
+
+type EventSource = webhook.Source | undefined;
+type MessageEvent = webhook.MessageEvent;
+type PostbackEvent = webhook.PostbackEvent;
+type StickerEventMessage = webhook.StickerMessageContent;
+
+interface MediaRef {
+  path: string;
+  contentType?: string;
+}
+
+interface BuildLineMessageContextParams {
+  event: MessageEvent;
+  allMedia: MediaRef[];
+  cfg: AutoBotConfig;
+  account: ResolvedLineAccount;
+  commandAuthorized: boolean;
+  groupHistories?: Map<string, HistoryEntry[]>;
+  historyLimit?: number;
+}
+
+type LineSourceInfo = {
+  userId?: string;
+  groupId?: string;
+  roomId?: string;
+  isGroup: boolean;
+};
+
+export function getLineSourceInfo(source: EventSource): LineSourceInfo {
+  if (!source) {
+    return { userId: undefined, groupId: undefined, roomId: undefined, isGroup: false };
+  }
+  const userId =
+    source.type === "user"
+      ? source.userId
+      : source.type === "group"
+        ? source.userId
+        : source.type === "room"
+          ? source.userId
+          : undefined;
+  const groupId = source.type === "group" ? source.groupId : undefined;
+  const roomId = source.type === "room" ? source.roomId : undefined;
+  const isGroup = source.type === "group" || source.type === "room";
+
+  return { userId, groupId, roomId, isGroup };
+}
+
+function buildPeerId(source: EventSource): string {
+  if (!source) {
+    return "unknown";
+  }
+  const groupKey =
+    normalizeOptionalString(source.type === "group" ? source.groupId : undefined) ??
+    normalizeOptionalString(source.type === "room" ? source.roomId : undefined);
+  if (groupKey) {
+    return groupKey;
+  }
+  if (source.type === "user" && source.userId) {
+    return source.userId;
+  }
+  return "unknown";
+}
+
+async function resolveLineInboundRoute(params: {
+  source: EventSource;
+  cfg: AutoBotConfig;
+  account: ResolvedLineAccount;
+}): Promise<{
+  userId?: string;
+  groupId?: string;
+  roomId?: string;
+  isGroup: boolean;
+  peerId: string;
+  route: ReturnType<typeof resolveAgentRoute>;
+}> {
+  recordChannelActivity({
+    channel: "line",
+    accountId: params.account.accountId,
+    direction: "inbound",
+  });
+
+  const { userId, groupId, roomId, isGroup } = getLineSourceInfo(params.source);
+  const peerId = buildPeerId(params.source);
+  let route = resolveAgentRoute({
+    cfg: params.cfg,
+    channel: "line",
+    accountId: params.account.accountId,
+    peer: {
+      kind: isGroup ? "group" : "direct",
+      id: peerId,
+    },
+  });
+
+  const configuredRoute = resolveConfiguredBindingRoute({
+    cfg: params.cfg,
+    route,
+    conversation: {
+      channel: "line",
+      accountId: params.account.accountId,
+      conversationId: peerId,
+    },
+  });
+  let configuredBinding = configuredRoute.bindingResolution;
+  const configuredBindingSessionKey = configuredRoute.boundSessionKey ?? "";
+  route = configuredRoute.route;
+
+  const runtimeRoute = resolveRuntimeConversationBindingRoute({
+    route,
+    conversation: {
+      channel: "line",
+      accountId: params.account.accountId,
+      conversationId: peerId,
+    },
+  });
+  route = runtimeRoute.route;
+  if (runtimeRoute.bindingRecord) {
+    configuredBinding = null;
+    logVerbose(
+      runtimeRoute.boundSessionKey
+        ? `line: routed via bound conversation ${peerId} -> ${runtimeRoute.boundSessionKey}`
+        : `line: plugin-bound conversation ${peerId}`,
+    );
+  }
+
+  if (configuredBinding) {
+    const ensured = await ensureConfiguredBindingRouteReady({
+      cfg: params.cfg,
+      bindingResolution: configuredBinding,
+    });
+    if (!ensured.ok) {
+      logVerbose(
+        `line: configured ACP binding unavailable for ${peerId} -> ${configuredBindingSessionKey}: ${ensured.error}`,
+      );
+      throw new Error(`Configured ACP binding unavailable: ${ensured.error}`);
+    }
+    logVerbose(
+      `line: using configured ACP binding for ${peerId} -> ${configuredBindingSessionKey}`,
+    );
+  }
+
+  return { userId, groupId, roomId, isGroup, peerId, route };
+}
+
+const STICKER_PACKAGES: Record<string, string> = {
+  "1": "Moon & James",
+  "2": "Cony & Brown",
+  "3": "Brown & Friends",
+  "4": "Moon Special",
+  "789": "LINE Characters",
+  "6136": "Cony's Happy Life",
+  "6325": "Brown's Life",
+  "6359": "Choco",
+  "6362": "Sally",
+  "6370": "Edward",
+  "11537": "Cony",
+  "11538": "Brown",
+  "11539": "Moon",
+};
+
+function describeStickerKeywords(sticker: StickerEventMessage): string {
+  const keywords = (sticker as StickerEventMessage & { keywords?: string[] }).keywords;
+  if (keywords && keywords.length > 0) {
+    return keywords.slice(0, 3).join(", ");
+  }
+
+  const stickerText = (sticker as StickerEventMessage & { text?: string }).text;
+  if (stickerText) {
+    return stickerText;
+  }
+
+  return "";
+}
+
+function extractMessageText(message: MessageEvent["message"]): string {
+  if (message.type === "text") {
+    return message.text;
+  }
+  if (message.type === "location") {
+    const loc = message;
+    return (
+      formatLocationText({
+        latitude: loc.latitude,
+        longitude: loc.longitude,
+        name: loc.title,
+        address: loc.address,
+      }) ?? ""
+    );
+  }
+  if (message.type === "sticker") {
+    const sticker = message;
+    const packageName = STICKER_PACKAGES[sticker.packageId] ?? "sticker";
+    const keywords = describeStickerKeywords(sticker);
+
+    if (keywords) {
+      return `[Sent a ${packageName} sticker: ${keywords}]`;
+    }
+    return `[Sent a ${packageName} sticker]`;
+  }
+  return "";
+}
+
+function extractMediaPlaceholder(message: MessageEvent["message"]): string {
+  switch (message.type) {
+    case "image":
+      return "<media:image>";
+    case "video":
+      return "<media:video>";
+    case "audio":
+      return "<media:audio>";
+    case "file":
+      return "<media:document>";
+    default:
+      return "";
+  }
+}
+
+type LineRouteInfo = ReturnType<typeof resolveAgentRoute>;
+type LineSourceInfoWithPeerId = LineSourceInfo & { peerId: string };
+
+function resolveLineConversationLabel(params: {
+  isGroup: boolean;
+  groupId?: string;
+  roomId?: string;
+  senderLabel: string;
+}): string {
+  return params.isGroup
+    ? params.groupId
+      ? `group:${params.groupId}`
+      : params.roomId
+        ? `room:${params.roomId}`
+        : "unknown-group"
+    : params.senderLabel;
+}
+
+function resolveLineAddresses(params: {
+  isGroup: boolean;
+  groupId?: string;
+  roomId?: string;
+  userId?: string;
+  peerId: string;
+}): { fromAddress: string; toAddress: string; originatingTo: string } {
+  const fromAddress = params.isGroup
+    ? params.groupId
+      ? `line:group:${params.groupId}`
+      : params.roomId
+        ? `line:room:${params.roomId}`
+        : `line:${params.peerId}`
+    : `line:${params.userId ?? params.peerId}`;
+  const toAddress = params.isGroup ? fromAddress : `line:${params.userId ?? params.peerId}`;
+  const originatingTo = params.isGroup ? fromAddress : `line:${params.userId ?? params.peerId}`;
+  return { fromAddress, toAddress, originatingTo };
+}
+
+async function finalizeLineInboundContext(params: {
+  cfg: AutoBotConfig;
+  account: ResolvedLineAccount;
+  event: MessageEvent | PostbackEvent;
+  route: LineRouteInfo;
+  source: LineSourceInfoWithPeerId;
+  rawBody: string;
+  timestamp: number;
+  messageSid: string;
+  commandAuthorized: boolean;
+  media: {
+    firstPath: string | undefined;
+    firstContentType?: string;
+    paths?: string[];
+    types?: string[];
+  };
+  locationContext?: ReturnType<typeof toLocationContext>;
+  verboseLog: { kind: "inbound" | "postback"; mediaCount?: number };
+  inboundHistory?: Pick<HistoryEntry, "sender" | "body" | "timestamp">[];
+}) {
+  const { fromAddress, toAddress, originatingTo } = resolveLineAddresses({
+    isGroup: params.source.isGroup,
+    groupId: params.source.groupId,
+    roomId: params.source.roomId,
+    userId: params.source.userId,
+    peerId: params.source.peerId,
+  });
+
+  const senderId = params.source.userId ?? "unknown";
+  const senderLabel = params.source.userId ? `user:${params.source.userId}` : "unknown";
+  const conversationLabel = resolveLineConversationLabel({
+    isGroup: params.source.isGroup,
+    groupId: params.source.groupId,
+    roomId: params.source.roomId,
+    senderLabel,
+  });
+
+  const { storePath, envelopeOptions, previousTimestamp } = resolveInboundSessionEnvelopeContext({
+    cfg: params.cfg,
+    agentId: params.route.agentId,
+    sessionKey: params.route.sessionKey,
+  });
+
+  const body = formatInboundEnvelope({
+    channel: "LINE",
+    from: conversationLabel,
+    timestamp: params.timestamp,
+    body: params.rawBody,
+    chatType: params.source.isGroup ? "group" : "direct",
+    sender: {
+      id: senderId,
+    },
+    previousTimestamp,
+    envelope: envelopeOptions,
+  });
+
+  const ctxPayload = finalizeInboundContext({
+    Body: body,
+    BodyForAgent: params.rawBody,
+    RawBody: params.rawBody,
+    CommandBody: params.rawBody,
+    From: fromAddress,
+    To: toAddress,
+    SessionKey: params.route.sessionKey,
+    AccountId: params.route.accountId,
+    ChatType: params.source.isGroup ? "group" : "direct",
+    ConversationLabel: conversationLabel,
+    GroupSubject: params.source.isGroup
+      ? (params.source.groupId ?? params.source.roomId)
+      : undefined,
+    SenderId: senderId,
+    Provider: "line",
+    Surface: "line",
+    MessageSid: params.messageSid,
+    Timestamp: params.timestamp,
+    MediaPath: params.media.firstPath,
+    MediaType: params.media.firstContentType,
+    MediaUrl: params.media.firstPath,
+    MediaPaths: params.media.paths,
+    MediaUrls: params.media.paths,
+    MediaTypes: params.media.types,
+    ...params.locationContext,
+    CommandAuthorized: params.commandAuthorized,
+    OriginatingChannel: "line" as const,
+    OriginatingTo: originatingTo,
+    GroupSystemPrompt: params.source.isGroup
+      ? normalizeOptionalString(
+          resolveLineGroupConfigEntry(params.account.config.groups, {
+            groupId: params.source.groupId,
+            roomId: params.source.roomId,
+          })?.systemPrompt,
+        )
+      : undefined,
+    InboundHistory: params.inboundHistory,
+  });
+
+  const pinnedMainDmOwner = !params.source.isGroup
+    ? resolvePinnedMainDmOwnerFromAllowlist({
+        dmScope: params.cfg.session?.dmScope,
+        allowFrom: params.account.config.allowFrom,
+        normalizeEntry: (entry) => normalizeAllowFrom([entry]).entries[0],
+      })
+    : null;
+  const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
+    route: params.route,
+    sessionKey: params.route.sessionKey,
+  });
+  if (shouldLogVerbose()) {
+    const preview = body.slice(0, 200).replace(/\n/g, "\\n");
+    const mediaInfo =
+      params.verboseLog.kind === "inbound" && (params.verboseLog.mediaCount ?? 0) > 1
+        ? ` mediaCount=${params.verboseLog.mediaCount}`
+        : "";
+    const label = params.verboseLog.kind === "inbound" ? "line inbound" : "line postback";
+    logVerbose(
+      `${label}: from=${ctxPayload.From} len=${body.length}${mediaInfo} preview="${preview}"`,
+    );
+  }
+
+  return {
+    ctxPayload,
+    replyToken: (params.event as { replyToken: string }).replyToken,
+    turn: {
+      storePath,
+      record: {
+        updateLastRoute: !params.source.isGroup
+          ? {
+              sessionKey: inboundLastRouteSessionKey,
+              channel: "line",
+              to: params.source.userId ?? params.source.peerId,
+              accountId: params.route.accountId,
+              mainDmOwnerPin:
+                inboundLastRouteSessionKey === params.route.mainSessionKey &&
+                pinnedMainDmOwner &&
+                params.source.userId
+                  ? {
+                      ownerRecipient: pinnedMainDmOwner,
+                      senderRecipient: params.source.userId,
+                      onSkip: ({
+                        ownerRecipient,
+                        senderRecipient,
+                      }: {
+                        ownerRecipient: string;
+                        senderRecipient: string;
+                      }) => {
+                        logVerbose(
+                          `line: skip main-session last route for ${senderRecipient} (pinned owner ${ownerRecipient})`,
+                        );
+                      },
+                    }
+                  : undefined,
+            }
+          : undefined,
+        onRecordError: (err: unknown) => {
+          logVerbose(`line: failed updating session meta: ${String(err)}`);
+        },
+      },
+    },
+  };
+}
+
+export async function buildLineMessageContext(params: BuildLineMessageContextParams) {
+  const { event, allMedia, cfg, account, commandAuthorized, groupHistories, historyLimit } = params;
+
+  const source = event.source;
+  const { userId, groupId, roomId, isGroup, peerId, route } = await resolveLineInboundRoute({
+    source,
+    cfg,
+    account,
+  });
+
+  const message = event.message;
+  const messageId = message.id;
+  const timestamp = event.timestamp;
+
+  const textContent = extractMessageText(message);
+  const placeholder = extractMediaPlaceholder(message);
+
+  let rawBody = textContent || placeholder;
+  if (!rawBody && allMedia.length > 0) {
+    rawBody = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
+  }
+
+  if (!rawBody && allMedia.length === 0) {
+    return null;
+  }
+
+  let locationContext: ReturnType<typeof toLocationContext> | undefined;
+  if (message.type === "location") {
+    const loc = message;
+    locationContext = toLocationContext({
+      latitude: loc.latitude,
+      longitude: loc.longitude,
+      name: loc.title,
+      address: loc.address,
+    });
+  }
+
+  const historyKey = isGroup ? peerId : undefined;
+  const inboundHistory =
+    historyKey && groupHistories && (historyLimit ?? 0) > 0
+      ? createChannelHistoryWindow({ historyMap: groupHistories }).buildInboundHistory({
+          historyKey,
+          limit: historyLimit ?? 0,
+        })
+      : undefined;
+
+  const finalized = await finalizeLineInboundContext({
+    cfg,
+    account,
+    event,
+    route,
+    source: { userId, groupId, roomId, isGroup, peerId },
+    rawBody,
+    timestamp,
+    messageSid: messageId,
+    commandAuthorized,
+    media: {
+      firstPath: allMedia[0]?.path,
+      firstContentType: allMedia[0]?.contentType,
+      paths: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined,
+      types:
+        allMedia.length > 0
+          ? (allMedia.map((m) => m.contentType).filter(Boolean) as string[])
+          : undefined,
+    },
+    locationContext,
+    verboseLog: { kind: "inbound", mediaCount: allMedia.length },
+    inboundHistory,
+  });
+
+  return {
+    ctxPayload: finalized.ctxPayload,
+    turn: finalized.turn,
+    event,
+    userId,
+    groupId,
+    roomId,
+    isGroup,
+    route,
+    replyToken: event.replyToken,
+    accountId: account.accountId,
+  };
+}
+
+export async function buildLinePostbackContext(params: {
+  event: PostbackEvent;
+  cfg: AutoBotConfig;
+  account: ResolvedLineAccount;
+  commandAuthorized: boolean;
+}) {
+  const { event, cfg, account, commandAuthorized } = params;
+
+  const source = event.source;
+  const { userId, groupId, roomId, isGroup, peerId, route } = await resolveLineInboundRoute({
+    source,
+    cfg,
+    account,
+  });
+
+  const timestamp = event.timestamp;
+  const rawData = event.postback?.data?.trim() ?? "";
+  if (!rawData) {
+    return null;
+  }
+  let rawBody = rawData;
+  if (rawData.includes("line.action=")) {
+    const searchParams = new URLSearchParams(rawData);
+    const action = searchParams.get("line.action") ?? "";
+    const device = searchParams.get("line.device");
+    rawBody = device ? `line action ${action} device ${device}` : `line action ${action}`;
+  }
+
+  const messageSid = event.replyToken ? `postback:${event.replyToken}` : `postback:${timestamp}`;
+  const finalized = await finalizeLineInboundContext({
+    cfg,
+    account,
+    event,
+    route,
+    source: { userId, groupId, roomId, isGroup, peerId },
+    rawBody,
+    timestamp,
+    messageSid,
+    commandAuthorized,
+    media: {
+      firstPath: "",
+      firstContentType: undefined,
+      paths: undefined,
+      types: undefined,
+    },
+    verboseLog: { kind: "postback" },
+  });
+
+  return {
+    ctxPayload: finalized.ctxPayload,
+    turn: finalized.turn,
+    event,
+    userId,
+    groupId,
+    roomId,
+    isGroup,
+    route,
+    replyToken: event.replyToken,
+    accountId: account.accountId,
+  };
+}
+
+type LineMessageContext = NonNullable<Awaited<ReturnType<typeof buildLineMessageContext>>>;
+type LinePostbackContext = NonNullable<Awaited<ReturnType<typeof buildLinePostbackContext>>>;
+export type LineInboundContext = LineMessageContext | LinePostbackContext;

package/src/bot.ts

@@ -0,0 +1,70 @@
+import type { webhook } from "@line/bot-sdk";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { DEFAULT_GROUP_HISTORY_LIMIT, type HistoryEntry } from "autobot/plugin-sdk/reply-history";
+import { getRuntimeConfig } from "autobot/plugin-sdk/runtime-config-snapshot";
+import {
+  createNonExitingRuntime,
+  logVerbose,
+  type RuntimeEnv,
+} from "autobot/plugin-sdk/runtime-env";
+import { resolveLineAccount } from "./accounts.js";
+import { createLineWebhookReplayCache, handleLineWebhookEvents } from "./bot-handlers.js";
+import type { LineInboundContext } from "./bot-message-context.js";
+import type { ResolvedLineAccount } from "./types.js";
+
+interface LineBotOptions {
+  channelAccessToken: string;
+  channelSecret: string;
+  accountId?: string;
+  runtime?: RuntimeEnv;
+  config?: AutoBotConfig;
+  mediaMaxMb?: number;
+  onMessage?: (ctx: LineInboundContext) => Promise<void>;
+}
+
+interface LineBot {
+  handleWebhook: (body: webhook.CallbackRequest) => Promise<void>;
+  account: ResolvedLineAccount;
+}
+
+export function createLineBot(opts: LineBotOptions): LineBot {
+  const runtime: RuntimeEnv = opts.runtime ?? createNonExitingRuntime();
+
+  const cfg = opts.config ?? getRuntimeConfig();
+  const account = resolveLineAccount({
+    cfg,
+    accountId: opts.accountId,
+  });
+
+  const mediaMaxBytes = (opts.mediaMaxMb ?? account.config.mediaMaxMb ?? 10) * 1024 * 1024;
+
+  const processMessage =
+    opts.onMessage ??
+    (async () => {
+      logVerbose("line: no message handler configured");
+    });
+  const replayCache = createLineWebhookReplayCache();
+  const groupHistories = new Map<string, HistoryEntry[]>();
+
+  const handleWebhook = async (body: webhook.CallbackRequest): Promise<void> => {
+    if (!body.events || body.events.length === 0) {
+      return;
+    }
+
+    await handleLineWebhookEvents(body.events, {
+      cfg,
+      account,
+      runtime,
+      mediaMaxBytes,
+      processMessage,
+      replayCache,
+      groupHistories,
+      historyLimit: cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT,
+    });
+  };
+
+  return {
+    handleWebhook,
+    account,
+  };
+}