@gakr-gakr/line 0.1.0

package/src/types.ts

@@ -0,0 +1,130 @@
+import type { BaseProbeResult } from "autobot/plugin-sdk/channel-contract";
+import type { MessageReceipt } from "autobot/plugin-sdk/channel-message";
+
+export type LineTokenSource = "config" | "env" | "file" | "none";
+
+interface LineThreadBindingsConfig {
+  enabled?: boolean;
+  idleHours?: number;
+  maxAgeHours?: number;
+  spawnSessions?: boolean;
+  defaultSpawnContext?: "isolated" | "fork";
+  /** @deprecated Use spawnSessions instead. */
+  spawnSubagentSessions?: boolean;
+  /** @deprecated Use spawnSessions instead. */
+  spawnAcpSessions?: boolean;
+}
+
+interface LineAccountBaseConfig {
+  enabled?: boolean;
+  channelAccessToken?: string;
+  channelSecret?: string;
+  tokenFile?: string;
+  secretFile?: string;
+  name?: string;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  dmPolicy?: "open" | "allowlist" | "pairing" | "disabled";
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  responsePrefix?: string;
+  mediaMaxMb?: number;
+  webhookPath?: string;
+  threadBindings?: LineThreadBindingsConfig;
+  groups?: Record<string, LineGroupConfig>;
+}
+
+export interface LineConfig extends LineAccountBaseConfig {
+  accounts?: Record<string, LineAccountConfig>;
+  defaultAccount?: string;
+}
+
+export interface LineAccountConfig extends LineAccountBaseConfig {}
+
+export interface LineGroupConfig {
+  enabled?: boolean;
+  allowFrom?: Array<string | number>;
+  requireMention?: boolean;
+  systemPrompt?: string;
+  skills?: string[];
+}
+
+export interface ResolvedLineAccount {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  channelAccessToken: string;
+  channelSecret: string;
+  tokenSource: LineTokenSource;
+  config: LineConfig & LineAccountConfig;
+}
+
+export interface LineSendResult {
+  messageId: string;
+  chatId: string;
+  receipt: MessageReceipt;
+}
+
+export type LineProbeResult = BaseProbeResult<string> & {
+  bot?: {
+    displayName?: string;
+    userId?: string;
+    basicId?: string;
+    pictureUrl?: string;
+  };
+};
+
+type LineFlexMessagePayload = {
+  altText: string;
+  contents: unknown;
+};
+
+export type LineTemplateMessagePayload =
+  | {
+      type: "confirm";
+      text: string;
+      confirmLabel: string;
+      confirmData: string;
+      cancelLabel: string;
+      cancelData: string;
+      altText?: string;
+    }
+  | {
+      type: "buttons";
+      title: string;
+      text: string;
+      actions: Array<{
+        type: "message" | "uri" | "postback";
+        label: string;
+        data?: string;
+        uri?: string;
+      }>;
+      thumbnailImageUrl?: string;
+      altText?: string;
+    }
+  | {
+      type: "carousel";
+      columns: Array<{
+        title?: string;
+        text: string;
+        thumbnailImageUrl?: string;
+        actions: Array<{
+          type: "message" | "uri" | "postback";
+          label: string;
+          data?: string;
+          uri?: string;
+        }>;
+      }>;
+      altText?: string;
+    };
+
+export type LineChannelData = {
+  quickReplies?: string[];
+  location?: {
+    title: string;
+    address: string;
+    latitude: number;
+    longitude: number;
+  };
+  flexMessage?: LineFlexMessagePayload;
+  templateMessage?: LineTemplateMessagePayload;
+};

package/src/webhook-node.ts

@@ -0,0 +1,155 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { webhook } from "@line/bot-sdk";
+import {
+  createMessageReceiveContext,
+  type MessageReceiveContext,
+} from "autobot/plugin-sdk/channel-message";
+import { danger, logVerbose, type RuntimeEnv } from "autobot/plugin-sdk/runtime-env";
+import {
+  isRequestBodyLimitError,
+  readRequestBodyWithLimit,
+  requestBodyErrorToText,
+} from "autobot/plugin-sdk/webhook-request-guards";
+import { parseLineWebhookBody, validateLineSignature } from "./webhook-utils.js";
+
+const LINE_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
+const LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES = 64 * 1024;
+const LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS = 5_000;
+
+export async function readLineWebhookRequestBody(
+  req: IncomingMessage,
+  maxBytes = LINE_WEBHOOK_MAX_BODY_BYTES,
+  timeoutMs = LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS,
+): Promise<string> {
+  return await readRequestBodyWithLimit(req, {
+    maxBytes,
+    timeoutMs,
+  });
+}
+
+type ReadBodyFn = (req: IncomingMessage, maxBytes: number, timeoutMs?: number) => Promise<string>;
+
+function logLineWebhookDispatchError(runtime: RuntimeEnv | undefined, err: unknown): void {
+  runtime?.error?.(danger(`line webhook dispatch failed: ${String(err)}`));
+}
+
+export function createLineNodeWebhookHandler(params: {
+  channelSecret: string;
+  bot: { handleWebhook: (body: webhook.CallbackRequest) => Promise<void> };
+  runtime: RuntimeEnv;
+  readBody?: ReadBodyFn;
+  maxBodyBytes?: number;
+  onRequestAuthenticated?: () => void;
+}): (req: IncomingMessage, res: ServerResponse) => Promise<void> {
+  const maxBodyBytes = params.maxBodyBytes ?? LINE_WEBHOOK_MAX_BODY_BYTES;
+  const readBody = params.readBody ?? readLineWebhookRequestBody;
+
+  return async (req: IncomingMessage, res: ServerResponse) => {
+    if (req.method === "GET" || req.method === "HEAD") {
+      if (req.method === "HEAD") {
+        res.statusCode = 204;
+        res.end();
+        return;
+      }
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/plain");
+      res.end("OK");
+      return;
+    }
+
+    if (req.method !== "POST") {
+      res.statusCode = 405;
+      res.setHeader("Allow", "GET, HEAD, POST");
+      res.setHeader("Content-Type", "application/json");
+      res.end(JSON.stringify({ error: "Method Not Allowed" }));
+      return;
+    }
+
+    let receiveContext: MessageReceiveContext<webhook.CallbackRequest> | undefined;
+    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 readBody(
+        req,
+        Math.min(maxBodyBytes, LINE_WEBHOOK_PREAUTH_MAX_BODY_BYTES),
+        LINE_WEBHOOK_PREAUTH_BODY_TIMEOUT_MS,
+      );
+
+      if (!validateLineSignature(rawBody, signature, params.channelSecret)) {
+        logVerbose("line: webhook signature validation failed");
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Invalid signature" }));
+        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;
+      }
+
+      params.onRequestAuthenticated?.();
+
+      receiveContext = createMessageReceiveContext({
+        id: `${Date.now()}:line:webhook`,
+        channel: "line",
+        message: body,
+        ackPolicy: "after_receive_record",
+        onAck: () => {
+          res.statusCode = 200;
+          res.setHeader("Content-Type", "application/json");
+          res.end(JSON.stringify({ status: "ok" }));
+        },
+      });
+
+      if (receiveContext.shouldAckAfter("receive_record")) {
+        await receiveContext.ack();
+      }
+
+      if (body.events && body.events.length > 0) {
+        logVerbose(`line: received ${body.events.length} webhook events`);
+        void Promise.resolve()
+          .then(() => params.bot.handleWebhook(body))
+          .catch((err) => logLineWebhookDispatchError(params.runtime, err));
+      }
+    } catch (err) {
+      await receiveContext?.nack(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;
+      }
+      params.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" }));
+      }
+    }
+  };
+}

package/src/webhook-utils.ts

@@ -0,0 +1,10 @@
+import type { webhook } from "@line/bot-sdk";
+export { validateLineSignature } from "./signature.js";
+
+export function parseLineWebhookBody(rawBody: string): webhook.CallbackRequest | null {
+  try {
+    return JSON.parse(rawBody) as webhook.CallbackRequest;
+  } catch {
+    return null;
+  }
+}

package/src/webhook.ts

@@ -0,0 +1,135 @@
+import type { webhook } from "@line/bot-sdk";
+import type { NextFunction, Request, Response } from "express";
+import {
+  createMessageReceiveContext,
+  type MessageReceiveContext,
+} from "autobot/plugin-sdk/channel-message";
+import { danger, logVerbose, type RuntimeEnv } from "autobot/plugin-sdk/runtime-env";
+import { parseLineWebhookBody, validateLineSignature } from "./webhook-utils.js";
+
+const LINE_WEBHOOK_MAX_RAW_BODY_BYTES = 64 * 1024;
+
+export interface LineWebhookOptions {
+  channelSecret: string;
+  onEvents: (body: webhook.CallbackRequest) => Promise<void>;
+  runtime?: RuntimeEnv;
+}
+
+function readRawBody(req: Request): string | null {
+  const rawBody =
+    (req as { rawBody?: string | Buffer }).rawBody ??
+    (typeof req.body === "string" || Buffer.isBuffer(req.body) ? req.body : null);
+  if (!rawBody) {
+    return null;
+  }
+  return Buffer.isBuffer(rawBody) ? rawBody.toString("utf-8") : rawBody;
+}
+
+function parseWebhookBody(rawBody?: string | null): webhook.CallbackRequest | null {
+  if (!rawBody) {
+    return null;
+  }
+  return parseLineWebhookBody(rawBody);
+}
+
+function logLineWebhookDispatchError(runtime: RuntimeEnv | undefined, err: unknown): void {
+  runtime?.error?.(danger(`line webhook dispatch failed: ${String(err)}`));
+}
+
+export function createLineWebhookMiddleware(
+  options: LineWebhookOptions,
+): (req: Request, res: Response, _next: NextFunction) => Promise<void> {
+  const { channelSecret, onEvents, runtime } = options;
+
+  return async (req: Request, res: Response, _next: NextFunction): Promise<void> => {
+    let receiveContext: MessageReceiveContext<webhook.CallbackRequest> | undefined;
+    try {
+      const signature = req.headers["x-line-signature"];
+
+      if (!signature || typeof signature !== "string") {
+        res.status(400).json({ error: "Missing X-Line-Signature header" });
+        return;
+      }
+
+      const rawBody = readRawBody(req);
+
+      if (!rawBody) {
+        res.status(400).json({ error: "Missing raw request body for signature verification" });
+        return;
+      }
+      if (Buffer.byteLength(rawBody, "utf-8") > LINE_WEBHOOK_MAX_RAW_BODY_BYTES) {
+        res.status(413).json({ error: "Payload too large" });
+        return;
+      }
+
+      if (!validateLineSignature(rawBody, signature, channelSecret)) {
+        logVerbose("line: webhook signature validation failed");
+        res.status(401).json({ error: "Invalid signature" });
+        return;
+      }
+
+      const body = parseWebhookBody(rawBody);
+
+      if (!body) {
+        res.status(400).json({ error: "Invalid webhook payload" });
+        return;
+      }
+
+      receiveContext = createMessageReceiveContext({
+        id: `${Date.now()}:line:webhook`,
+        channel: "line",
+        message: body,
+        ackPolicy: "after_receive_record",
+        onAck: () => {
+          res.status(200).json({ status: "ok" });
+        },
+      });
+
+      if (receiveContext.shouldAckAfter("receive_record")) {
+        await receiveContext.ack();
+      }
+
+      if (body.events && body.events.length > 0) {
+        logVerbose(`line: received ${body.events.length} webhook events`);
+        void Promise.resolve()
+          .then(() => onEvents(body))
+          .catch((err) => logLineWebhookDispatchError(runtime, err));
+      }
+    } catch (err) {
+      await receiveContext?.nack(err);
+      runtime?.error?.(danger(`line webhook error: ${String(err)}`));
+      if (!res.headersSent) {
+        res.status(500).json({ error: "Internal server error" });
+      }
+    }
+  };
+}
+
+export interface StartLineWebhookOptions {
+  channelSecret: string;
+  onEvents: (body: webhook.CallbackRequest) => Promise<void>;
+  runtime?: RuntimeEnv;
+  path?: string;
+}
+
+export function startLineWebhook(options: StartLineWebhookOptions): {
+  path: string;
+  handler: (req: Request, res: Response, _next: NextFunction) => Promise<void>;
+} {
+  const channelSecret =
+    typeof options.channelSecret === "string" ? options.channelSecret.trim() : "";
+  if (!channelSecret) {
+    throw new Error(
+      "LINE webhook mode requires a non-empty channel secret. " +
+        "Set channels.line.channelSecret in your config.",
+    );
+  }
+  const path = options.path ?? "/line/webhook";
+  const middleware = createLineWebhookMiddleware({
+    channelSecret,
+    onEvents: options.onEvents,
+    runtime: options.runtime,
+  });
+
+  return { path, handler: middleware };
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}