@gakr-gakr/line 0.1.0

package/src/monitor.ts

@@ -0,0 +1,507 @@
+import type { webhook } from "@line/bot-sdk";
+import { hasFinalChannelTurnDispatch } from "autobot/plugin-sdk/channel-message";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { chunkMarkdownText } from "autobot/plugin-sdk/reply-runtime";
+import {
+  danger,
+  logVerbose,
+  waitForAbortSignal,
+  type RuntimeEnv,
+} from "autobot/plugin-sdk/runtime-env";
+import {
+  isRequestBodyLimitError,
+  normalizePluginHttpPath,
+  registerWebhookTargetWithPluginRoute,
+  requestBodyErrorToText,
+  resolveSingleWebhookTarget,
+} from "autobot/plugin-sdk/webhook-ingress";
+import {
+  beginWebhookRequestPipelineOrReject,
+  createWebhookInFlightLimiter,
+} from "autobot/plugin-sdk/webhook-request-guards";
+import { resolveDefaultLineAccountId } from "./accounts.js";
+import { deliverLineAutoReply } from "./auto-reply-delivery.js";
+import { createLineBot } from "./bot.js";
+import { processLineMessage } from "./markdown-to-line.js";
+import { resolveLineDurableReplyOptions } from "./monitor-durable.js";
+import { sendLineReplyChunks } from "./reply-chunks.js";
+import { getLineRuntime } from "./runtime.js";
+import {
+  createFlexMessage,
+  createImageMessage,
+  createLocationMessage,
+  createQuickReplyItems,
+  createTextMessageWithQuickReplies,
+  getUserDisplayName,
+  pushMessageLine,
+  pushMessagesLine,
+  pushTextMessageWithQuickReplies,
+  replyMessageLine,
+  showLoadingAnimation,
+} from "./send.js";
+import { buildTemplateMessageFromPayload } from "./template-messages.js";
+import type { LineChannelData, ResolvedLineAccount } from "./types.js";
+import { createLineNodeWebhookHandler, readLineWebhookRequestBody } from "./webhook-node.js";
+import { parseLineWebhookBody, validateLineSignature } from "./webhook-utils.js";
+
+export interface MonitorLineProviderOptions {
+  channelAccessToken: string;
+  channelSecret: string;
+  accountId?: string;
+  config: AutoBotConfig;
+  runtime: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  webhookUrl?: string;
+  webhookPath?: string;
+}
+
+export interface LineProviderMonitor {
+  account: ResolvedLineAccount;
+  handleWebhook: (body: webhook.CallbackRequest) => Promise<void>;
+  stop: () => void;
+}
+
+const runtimeState = new Map<
+  string,
+  {
+    running: boolean;
+    lastStartAt: number | null;
+    lastStopAt: number | null;
+    lastError: string | null;
+    lastInboundAt?: number | null;
+    lastOutboundAt?: number | null;
+  }
+>();
+const lineWebhookInFlightLimiter = createWebhookInFlightLimiter();
+const LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES = 64 * 1024;
+const LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS = 5_000;
+
+type LineWebhookTarget = {
+  accountId: string;
+  bot: ReturnType<typeof createLineBot>;
+  channelSecret: string;
+  path: string;
+  runtime: RuntimeEnv;
+};
+
+const lineWebhookTargets = new Map<string, LineWebhookTarget[]>();
+
+function recordChannelRuntimeState(params: {
+  channel: string;
+  accountId: string;
+  state: Partial<{
+    running: boolean;
+    lastStartAt: number | null;
+    lastStopAt: number | null;
+    lastError: string | null;
+    lastInboundAt: number | null;
+    lastOutboundAt: number | null;
+  }>;
+}): void {
+  const key = `${params.channel}:${params.accountId}`;
+  const existing = runtimeState.get(key) ?? {
+    running: false,
+    lastStartAt: null,
+    lastStopAt: null,
+    lastError: null,
+  };
+  runtimeState.set(key, { ...existing, ...params.state });
+}
+
+export function getLineRuntimeState(accountId: string) {
+  return runtimeState.get(`line:${accountId}`);
+}
+
+export function clearLineRuntimeStateForTests() {
+  runtimeState.clear();
+}
+
+function startLineLoadingKeepalive(params: {
+  cfg: AutoBotConfig;
+  userId: string;
+  accountId?: string;
+  intervalMs?: number;
+  loadingSeconds?: number;
+}): () => void {
+  const intervalMs = params.intervalMs ?? 18_000;
+  const loadingSeconds = params.loadingSeconds ?? 20;
+  let stopped = false;
+
+  const trigger = () => {
+    if (stopped) {
+      return;
+    }
+    void showLoadingAnimation(params.userId, {
+      cfg: params.cfg,
+      accountId: params.accountId,
+      loadingSeconds,
+    }).catch(() => {});
+  };
+
+  trigger();
+  const timer = setInterval(trigger, intervalMs);
+
+  return () => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+
+export async function monitorLineProvider(
+  opts: MonitorLineProviderOptions,
+): Promise<LineProviderMonitor> {
+  const {
+    channelAccessToken,
+    channelSecret,
+    accountId,
+    config,
+    runtime,
+    abortSignal,
+    webhookPath,
+  } = opts;
+  const resolvedAccountId = accountId ?? resolveDefaultLineAccountId(config);
+  const token = channelAccessToken.trim();
+  const secret = channelSecret.trim();
+
+  if (!token) {
+    throw new Error("LINE webhook mode requires a non-empty channel access token.");
+  }
+  if (!secret) {
+    throw new Error("LINE webhook mode requires a non-empty channel secret.");
+  }
+
+  recordChannelRuntimeState({
+    channel: "line",
+    accountId: resolvedAccountId,
+    state: {
+      running: true,
+      lastStartAt: Date.now(),
+    },
+  });
+
+  const bot = createLineBot({
+    channelAccessToken: token,
+    channelSecret: secret,
+    accountId,
+    runtime,
+    config,
+    onMessage: async (ctx) => {
+      if (!ctx) {
+        return;
+      }
+
+      const { ctxPayload, replyToken, route } = ctx;
+
+      recordChannelRuntimeState({
+        channel: "line",
+        accountId: resolvedAccountId,
+        state: {
+          lastInboundAt: Date.now(),
+        },
+      });
+
+      const shouldShowLoading = Boolean(ctx.userId && !ctx.isGroup);
+
+      const displayNamePromise = ctx.userId
+        ? getUserDisplayName(ctx.userId, { cfg: config, accountId: ctx.accountId })
+        : Promise.resolve(ctxPayload.From);
+
+      const stopLoading = shouldShowLoading
+        ? startLineLoadingKeepalive({
+            cfg: config,
+            userId: ctx.userId!,
+            accountId: ctx.accountId,
+          })
+        : null;
+
+      const displayName = await displayNamePromise;
+      logVerbose(`line: received message from ${displayName} (${ctxPayload.From})`);
+
+      try {
+        const textLimit = 5000;
+        let replyTokenUsed = false;
+        const core = getLineRuntime();
+        const turnResult = await core.channel.turn.run({
+          channel: "line",
+          accountId: route.accountId,
+          raw: ctx,
+          adapter: {
+            ingest: () => ({
+              id: ctxPayload.MessageSid ?? `${ctxPayload.From}:${Date.now()}`,
+              rawText: ctxPayload.RawBody ?? ctxPayload.BodyForAgent ?? "",
+            }),
+            resolveTurn: () => ({
+              cfg: config,
+              channel: "line",
+              accountId: route.accountId,
+              agentId: route.agentId,
+              routeSessionKey: route.sessionKey,
+              storePath: ctx.turn.storePath,
+              ctxPayload,
+              recordInboundSession: core.channel.session.recordInboundSession,
+              dispatchReplyWithBufferedBlockDispatcher:
+                core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
+              record: ctx.turn.record,
+              replyPipeline: {},
+              delivery: {
+                durable: (payload, info) =>
+                  resolveLineDurableReplyOptions({
+                    payload,
+                    infoKind: info.kind,
+                    to: ctxPayload.From,
+                    replyToken,
+                    replyTokenUsed,
+                  }),
+                deliver: async (payload) => {
+                  const lineData = (payload.channelData?.line as LineChannelData | undefined) ?? {};
+
+                  if (ctx.userId && !ctx.isGroup) {
+                    void showLoadingAnimation(ctx.userId, {
+                      cfg: config,
+                      accountId: ctx.accountId,
+                    }).catch(() => {});
+                  }
+
+                  const { replyTokenUsed: nextReplyTokenUsed } = await deliverLineAutoReply({
+                    payload,
+                    lineData,
+                    to: ctxPayload.From,
+                    replyToken,
+                    replyTokenUsed,
+                    accountId: ctx.accountId,
+                    cfg: config,
+                    textLimit,
+                    deps: {
+                      buildTemplateMessageFromPayload,
+                      processLineMessage,
+                      chunkMarkdownText,
+                      sendLineReplyChunks,
+                      replyMessageLine,
+                      pushMessageLine,
+                      pushTextMessageWithQuickReplies,
+                      createQuickReplyItems,
+                      createTextMessageWithQuickReplies,
+                      pushMessagesLine,
+                      createFlexMessage,
+                      createImageMessage,
+                      createLocationMessage,
+                      onReplyError: (replyErr) => {
+                        logVerbose(
+                          `line: reply token failed, falling back to push: ${String(replyErr)}`,
+                        );
+                      },
+                    },
+                  });
+                  replyTokenUsed = nextReplyTokenUsed;
+
+                  recordChannelRuntimeState({
+                    channel: "line",
+                    accountId: resolvedAccountId,
+                    state: {
+                      lastOutboundAt: Date.now(),
+                    },
+                  });
+                },
+                onError: (err, info) => {
+                  runtime.error?.(danger(`line ${info.kind} reply failed: ${String(err)}`));
+                },
+              },
+            }),
+          },
+        });
+        const dispatchResult = turnResult.dispatched ? turnResult.dispatchResult : undefined;
+        if (!hasFinalChannelTurnDispatch(dispatchResult)) {
+          logVerbose(`line: no response generated for message from ${ctxPayload.From}`);
+        }
+      } catch (err) {
+        runtime.error?.(danger(`line: auto-reply failed: ${String(err)}`));
+
+        if (replyToken) {
+          try {
+            await replyMessageLine(
+              replyToken,
+              [{ type: "text", text: "Sorry, I encountered an error processing your message." }],
+              { cfg: config, accountId: ctx.accountId },
+            );
+          } catch (replyErr) {
+            runtime.error?.(danger(`line: error reply failed: ${String(replyErr)}`));
+          }
+        }
+      } finally {
+        stopLoading?.();
+      }
+    },
+  });
+
+  const normalizedPath = normalizePluginHttpPath(webhookPath, "/line/webhook") ?? "/line/webhook";
+  const createScopedLineWebhookHandler = (target: LineWebhookTarget) =>
+    createLineNodeWebhookHandler({
+      channelSecret: target.channelSecret,
+      bot: target.bot,
+      runtime: target.runtime,
+    });
+  const { unregister: unregisterHttp } = registerWebhookTargetWithPluginRoute({
+    targetsByPath: lineWebhookTargets,
+    target: {
+      accountId: resolvedAccountId,
+      bot,
+      channelSecret: secret,
+      path: normalizedPath,
+      runtime,
+    },
+    route: {
+      auth: "plugin",
+      pluginId: "line",
+      accountId: resolvedAccountId,
+      log: (msg) => logVerbose(msg),
+      handler: async (req, res) => {
+        const targets = lineWebhookTargets.get(normalizedPath) ?? [];
+        const firstTarget = targets[0];
+        if (req.method !== "POST") {
+          if (!firstTarget) {
+            res.statusCode = 404;
+            res.end("Not Found");
+            return;
+          }
+          await createScopedLineWebhookHandler(firstTarget)(req, res);
+          return;
+        }
+
+        const requestLifecycle = beginWebhookRequestPipelineOrReject({
+          req,
+          res,
+          inFlightLimiter: lineWebhookInFlightLimiter,
+          inFlightKey: `line:${normalizedPath}`,
+        });
+        if (!requestLifecycle.ok) {
+          return;
+        }
+
+        try {
+          const signatureHeader = req.headers["x-line-signature"];
+          const signature =
+            typeof signatureHeader === "string"
+              ? signatureHeader.trim()
+              : Array.isArray(signatureHeader)
+                ? (signatureHeader[0] ?? "").trim()
+                : "";
+
+          if (!signature) {
+            logVerbose("line: webhook missing X-Line-Signature header");
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Missing X-Line-Signature header" }));
+            return;
+          }
+
+          const rawBody = await readLineWebhookRequestBody(
+            req,
+            LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES,
+            LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS,
+          );
+          const match = resolveSingleWebhookTarget(targets, (target) =>
+            validateLineSignature(rawBody, signature, target.channelSecret),
+          );
+          if (match.kind === "none") {
+            logVerbose("line: webhook signature validation failed");
+            res.statusCode = 401;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Invalid signature" }));
+            return;
+          }
+          if (match.kind === "ambiguous") {
+            logVerbose("line: webhook signature matched multiple accounts");
+            res.statusCode = 401;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Ambiguous webhook target" }));
+            return;
+          }
+
+          const body = parseLineWebhookBody(rawBody);
+          if (!body) {
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Invalid webhook payload" }));
+            return;
+          }
+
+          requestLifecycle.release();
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ status: "ok" }));
+
+          if (body.events && body.events.length > 0) {
+            logVerbose(`line: received ${body.events.length} webhook events`);
+            void Promise.resolve()
+              .then(() => match.target.bot.handleWebhook(body))
+              .catch((err) => {
+                match.target.runtime.error?.(
+                  danger(`line webhook dispatch failed: ${String(err)}`),
+                );
+              });
+          }
+        } catch (err) {
+          if (isRequestBodyLimitError(err, "PAYLOAD_TOO_LARGE")) {
+            res.statusCode = 413;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Payload too large" }));
+            return;
+          }
+          if (isRequestBodyLimitError(err, "REQUEST_BODY_TIMEOUT")) {
+            res.statusCode = 408;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: requestBodyErrorToText("REQUEST_BODY_TIMEOUT") }));
+            return;
+          }
+          runtime.error?.(danger(`line webhook error: ${String(err)}`));
+          if (!res.headersSent) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({ error: "Internal server error" }));
+          }
+        } finally {
+          requestLifecycle.release();
+        }
+      },
+    },
+  });
+
+  logVerbose(`line: registered webhook handler at ${normalizedPath}`);
+
+  let stopped = false;
+  const stopHandler = () => {
+    if (stopped) {
+      return;
+    }
+    stopped = true;
+    logVerbose(`line: stopping provider for account ${resolvedAccountId}`);
+    unregisterHttp();
+    recordChannelRuntimeState({
+      channel: "line",
+      accountId: resolvedAccountId,
+      state: {
+        running: false,
+        lastStopAt: Date.now(),
+      },
+    });
+  };
+
+  if (abortSignal?.aborted) {
+    stopHandler();
+  } else if (abortSignal) {
+    abortSignal.addEventListener("abort", stopHandler, { once: true });
+    await waitForAbortSignal(abortSignal);
+  }
+
+  return {
+    account: bot.account,
+    handleWebhook: bot.handleWebhook,
+    stop: () => {
+      stopHandler();
+      abortSignal?.removeEventListener("abort", stopHandler);
+    },
+  };
+}

package/src/outbound-media.ts

@@ -0,0 +1,120 @@
+import { resolvePinnedHostnameWithPolicy, type SsrFPolicy } from "autobot/plugin-sdk/ssrf-runtime";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+
+type LineOutboundMediaKind = "image" | "video" | "audio";
+
+export type LineOutboundMediaResolved = {
+  mediaUrl: string;
+  mediaKind: LineOutboundMediaKind;
+  previewImageUrl?: string;
+  durationMs?: number;
+  trackingId?: string;
+};
+
+type ResolveLineOutboundMediaOpts = {
+  mediaKind?: LineOutboundMediaKind;
+  previewImageUrl?: string;
+  durationMs?: number;
+  trackingId?: string;
+};
+
+const LINE_OUTBOUND_MEDIA_SSRF_POLICY: SsrFPolicy = {
+  allowPrivateNetwork: false,
+};
+
+export async function validateLineMediaUrl(url: string): Promise<void> {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`LINE outbound media URL must be a valid URL: ${url}`);
+  }
+  if (parsed.protocol !== "https:") {
+    throw new Error(`LINE outbound media URL must use HTTPS: ${url}`);
+  }
+  if (url.length > 2000) {
+    throw new Error(`LINE outbound media URL must be 2000 chars or less (got ${url.length})`);
+  }
+  await resolvePinnedHostnameWithPolicy(parsed.hostname, {
+    policy: LINE_OUTBOUND_MEDIA_SSRF_POLICY,
+  });
+}
+
+export function detectLineMediaKind(mimeType: string): LineOutboundMediaKind {
+  const normalized = normalizeLowercaseStringOrEmpty(mimeType);
+  if (normalized.startsWith("image/")) {
+    return "image";
+  }
+  if (normalized.startsWith("video/")) {
+    return "video";
+  }
+  if (normalized.startsWith("audio/")) {
+    return "audio";
+  }
+  return "image";
+}
+
+function isHttpsUrl(url: string): boolean {
+  try {
+    return new URL(url).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+function detectLineMediaKindFromUrl(url: string): LineOutboundMediaKind | undefined {
+  try {
+    const pathname = normalizeLowercaseStringOrEmpty(new URL(url).pathname);
+    if (/\.(png|jpe?g|gif|webp|bmp|heic|heif|avif)$/i.test(pathname)) {
+      return "image";
+    }
+    if (/\.(mp4|mov|m4v|webm)$/i.test(pathname)) {
+      return "video";
+    }
+    if (/\.(mp3|m4a|aac|wav|ogg|oga)$/i.test(pathname)) {
+      return "audio";
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+export async function resolveLineOutboundMedia(
+  mediaUrl: string,
+  opts: ResolveLineOutboundMediaOpts = {},
+): Promise<LineOutboundMediaResolved> {
+  const trimmedUrl = mediaUrl.trim();
+  if (isHttpsUrl(trimmedUrl)) {
+    await validateLineMediaUrl(trimmedUrl);
+    const previewImageUrl = opts.previewImageUrl?.trim();
+    if (previewImageUrl) {
+      await validateLineMediaUrl(previewImageUrl);
+    }
+    const mediaKind =
+      opts.mediaKind ??
+      (typeof opts.durationMs === "number" ? "audio" : undefined) ??
+      (opts.trackingId?.trim() ? "video" : undefined) ??
+      detectLineMediaKindFromUrl(trimmedUrl) ??
+      "image";
+    return {
+      mediaUrl: trimmedUrl,
+      mediaKind,
+      ...(previewImageUrl ? { previewImageUrl } : {}),
+      ...(typeof opts.durationMs === "number" ? { durationMs: opts.durationMs } : {}),
+      ...(opts.trackingId ? { trackingId: opts.trackingId } : {}),
+    };
+  }
+
+  try {
+    const parsed = new URL(trimmedUrl);
+    if (parsed.protocol !== "https:") {
+      throw new Error(`LINE outbound media URL must use HTTPS: ${trimmedUrl}`);
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("LINE outbound")) {
+      throw e;
+    }
+  }
+  throw new Error("LINE outbound media currently requires a public HTTPS URL");
+}

package/src/outbound.runtime.ts

@@ -0,0 +1,12 @@
+export { processLineMessage } from "./markdown-to-line.js";
+export {
+  createQuickReplyItems,
+  pushFlexMessage,
+  pushLocationMessage,
+  pushMessageLine,
+  pushMessagesLine,
+  pushTemplateMessage,
+  pushTextMessageWithQuickReplies,
+  sendMessageLine,
+} from "./send.js";
+export { buildTemplateMessageFromPayload } from "./template-messages.js";