@kodelyth/line 2026.5.42 → 2026.6.2

package/src/monitor.ts

@@ -1,507 +0,0 @@
-import type { webhook } from "@line/bot-sdk";
-import { hasFinalChannelTurnDispatch } from "klaw/plugin-sdk/channel-message";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { chunkMarkdownText } from "klaw/plugin-sdk/reply-runtime";
-import {
-  danger,
-  logVerbose,
-  waitForAbortSignal,
-  type RuntimeEnv,
-} from "klaw/plugin-sdk/runtime-env";
-import {
-  isRequestBodyLimitError,
-  normalizePluginHttpPath,
-  registerWebhookTargetWithPluginRoute,
-  requestBodyErrorToText,
-  resolveSingleWebhookTarget,
-} from "klaw/plugin-sdk/webhook-ingress";
-import {
-  beginWebhookRequestPipelineOrReject,
-  createWebhookInFlightLimiter,
-} from "klaw/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: KlawConfig;
-  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: KlawConfig;
-  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.test.ts

@@ -1,194 +0,0 @@
-import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-const ssrfMocks = vi.hoisted(() => ({
-  resolvePinnedHostnameWithPolicy: vi.fn(),
-}));
-
-vi.mock("klaw/plugin-sdk/ssrf-runtime", () => ({
-  resolvePinnedHostnameWithPolicy: ssrfMocks.resolvePinnedHostnameWithPolicy,
-}));
-
-afterAll(() => {
-  vi.doUnmock("klaw/plugin-sdk/ssrf-runtime");
-  vi.resetModules();
-});
-
-import {
-  detectLineMediaKind,
-  resolveLineOutboundMedia,
-  validateLineMediaUrl,
-} from "./outbound-media.js";
-
-describe("validateLineMediaUrl", () => {
-  beforeEach(() => {
-    ssrfMocks.resolvePinnedHostnameWithPolicy.mockReset();
-    ssrfMocks.resolvePinnedHostnameWithPolicy.mockResolvedValue({
-      hostname: "example.com",
-      addresses: ["93.184.216.34"],
-    });
-  });
-
-  it("accepts HTTPS URL", async () => {
-    await expect(validateLineMediaUrl("https://example.com/image.jpg")).resolves.toBeUndefined();
-    expect(ssrfMocks.resolvePinnedHostnameWithPolicy).toHaveBeenCalledWith("example.com", {
-      policy: { allowPrivateNetwork: false },
-    });
-  });
-
-  it("accepts uppercase HTTPS scheme", async () => {
-    await expect(validateLineMediaUrl("HTTPS://EXAMPLE.COM/img.jpg")).resolves.toBeUndefined();
-    expect(ssrfMocks.resolvePinnedHostnameWithPolicy).toHaveBeenCalledWith("example.com", {
-      policy: { allowPrivateNetwork: false },
-    });
-  });
-
-  it("rejects HTTP URL", async () => {
-    await expect(validateLineMediaUrl("http://example.com/image.jpg")).rejects.toThrow(
-      /must use HTTPS/i,
-    );
-    expect(ssrfMocks.resolvePinnedHostnameWithPolicy).not.toHaveBeenCalled();
-  });
-
-  it("rejects URL longer than 2000 chars", async () => {
-    const longUrl = `https://example.com/${"a".repeat(1981)}`;
-    expect(longUrl.length).toBeGreaterThan(2000);
-    await expect(validateLineMediaUrl(longUrl)).rejects.toThrow(/2000 chars or less/i);
-    expect(ssrfMocks.resolvePinnedHostnameWithPolicy).not.toHaveBeenCalled();
-  });
-
-  it("rejects private-network targets through the shared SSRF policy", async () => {
-    ssrfMocks.resolvePinnedHostnameWithPolicy.mockRejectedValueOnce(
-      new Error("SSRF blocked private network target"),
-    );
-
-    await expect(validateLineMediaUrl("https://127.0.0.1/image.jpg")).rejects.toThrow(
-      /private network/i,
-    );
-    expect(ssrfMocks.resolvePinnedHostnameWithPolicy).toHaveBeenCalledWith("127.0.0.1", {
-      policy: { allowPrivateNetwork: false },
-    });
-  });
-});
-
-describe("detectLineMediaKind", () => {
-  it("maps image MIME to image", () => {
-    expect(detectLineMediaKind("image/jpeg")).toBe("image");
-  });
-
-  it("maps uppercase image MIME to image", () => {
-    expect(detectLineMediaKind("IMAGE/JPEG")).toBe("image");
-  });
-
-  it("maps video MIME to video", () => {
-    expect(detectLineMediaKind("video/mp4")).toBe("video");
-  });
-
-  it("maps audio MIME to audio", () => {
-    expect(detectLineMediaKind("audio/mpeg")).toBe("audio");
-  });
-
-  it("falls back unknown MIME to image", () => {
-    expect(detectLineMediaKind("application/octet-stream")).toBe("image");
-  });
-});
-
-describe("resolveLineOutboundMedia", () => {
-  beforeEach(() => {
-    ssrfMocks.resolvePinnedHostnameWithPolicy.mockReset();
-    ssrfMocks.resolvePinnedHostnameWithPolicy.mockResolvedValue({
-      hostname: "example.com",
-      addresses: ["93.184.216.34"],
-    });
-  });
-
-  it("respects explicit media kind without remote MIME probing", async () => {
-    await expect(
-      resolveLineOutboundMedia("https://example.com/download?id=123", { mediaKind: "video" }),
-    ).resolves.toEqual({
-      mediaUrl: "https://example.com/download?id=123",
-      mediaKind: "video",
-    });
-  });
-
-  it("preserves explicit video kind when a preview URL is provided", async () => {
-    await expect(
-      resolveLineOutboundMedia("https://example.com/download?id=123", {
-        mediaKind: "video",
-        previewImageUrl: "https://example.com/preview.jpg",
-      }),
-    ).resolves.toEqual({
-      mediaUrl: "https://example.com/download?id=123",
-      mediaKind: "video",
-      previewImageUrl: "https://example.com/preview.jpg",
-    });
-  });
-
-  it("infers audio kind from explicit duration metadata when mediaKind is omitted", async () => {
-    await expect(
-      resolveLineOutboundMedia("https://example.com/download?id=audio", {
-        durationMs: 60000,
-      }),
-    ).resolves.toEqual({
-      mediaUrl: "https://example.com/download?id=audio",
-      mediaKind: "audio",
-      durationMs: 60000,
-    });
-  });
-
-  it("does not infer video from previewImageUrl alone", async () => {
-    await expect(
-      resolveLineOutboundMedia("https://example.com/image.jpg", {
-        previewImageUrl: "https://example.com/preview.jpg",
-      }),
-    ).resolves.toEqual({
-      mediaUrl: "https://example.com/image.jpg",
-      mediaKind: "image",
-      previewImageUrl: "https://example.com/preview.jpg",
-    });
-  });
-
-  it("infers media kinds from known HTTPS file extensions", async () => {
-    await expect(resolveLineOutboundMedia("https://example.com/audio.mp3")).resolves.toEqual({
-      mediaUrl: "https://example.com/audio.mp3",
-      mediaKind: "audio",
-    });
-    await expect(resolveLineOutboundMedia("https://example.com/video.mp4")).resolves.toEqual({
-      mediaUrl: "https://example.com/video.mp4",
-      mediaKind: "video",
-    });
-    await expect(resolveLineOutboundMedia("https://example.com/image.jpg")).resolves.toEqual({
-      mediaUrl: "https://example.com/image.jpg",
-      mediaKind: "image",
-    });
-  });
-
-  it("validates previewImageUrl when provided", async () => {
-    await expect(
-      resolveLineOutboundMedia("https://example.com/video.mp4", {
-        mediaKind: "video",
-        previewImageUrl: "http://example.com/preview.jpg",
-      }),
-    ).rejects.toThrow(/must use HTTPS/i);
-  });
-
-  it("falls back to image when no explicit LINE media options or known extension are present", async () => {
-    await expect(
-      resolveLineOutboundMedia("https://example.com/download?id=audio"),
-    ).resolves.toEqual({
-      mediaUrl: "https://example.com/download?id=audio",
-      mediaKind: "image",
-    });
-  });
-
-  it("rejects local paths because LINE outbound media requires public HTTPS URLs", async () => {
-    await expect(resolveLineOutboundMedia("./assets/image.jpg")).rejects.toThrow(
-      /requires a public https url/i,
-    );
-  });
-
-  it("rejects non-HTTPS URL explicitly", async () => {
-    await expect(resolveLineOutboundMedia("http://example.com/image.jpg")).rejects.toThrow(
-      /must use HTTPS/i,
-    );
-  });
-});