@zhin.js/adapter-line 0.1.0 → 1.1.0

package/lib/index.d.ts

@@ -1,15 +1,4 @@
-import { LineAdapter } from './adapter.js';
-declare module 'zhin.js' {
-    namespace Plugin {
-        interface Contexts {
-            router: import('@zhin.js/host-router').Router;
-        }
-    }
-    interface Adapters {
-        line: LineAdapter;
-    }
-}
-export * from './types.js';
-export { LineEndpoint } from './endpoint.js';
-export { LineAdapter } from './adapter.js';
-//# sourceMappingURL=index.d.ts.map
+export { formatInboundContent, formatOutboundMessages, generateMessageId, isMessageEvent, isPostbackEvent, isValidLineRecipientId, normalizeWebhookPath, readTextBody, resolveChannel, resolveLineConfig, verifySignature, type LineAdapterConfig, type LineApiResponse, type LineChannel, type LineEvent, type LineFollowEvent, type LineJoinEvent, type LineLeaveEvent, type LineMessage, type LineMessageEvent, type LinePostbackEvent, type LinePushRequest, type LineReplyMessage, type LineReplyRequest, type LineSource, type LineUnfollowEvent, type LineUser, type LineWebhookBody, type LineWireSegment, type ResolvedLineConfig, } from './protocol.js';
+export { LineEndpoint, type LineEndpointOptions, type LineFetch, } from './endpoint.js';
+export { registerLineWebhookRoutes, handleLineWebhookRequest, type LineWebhookHandler, } from './webhook.js';
+export { LineClient, lineClient, type LineClientEventMap, type LineGroupMember, } from './client.js';

package/lib/index.js

@@ -1,83 +1,4 @@
-/**
- * LINE Messaging API 适配器入口：类型扩展、导出、注册
- */
-import { usePlugin } from 'zhin.js';
-import { LineAdapter } from './adapter.js';
-export * from './types.js';
-export { LineEndpoint } from './endpoint.js';
-export { LineAdapter } from './adapter.js';
-const plugin = usePlugin();
-const { provide, useContext } = plugin;
-useContext('router', (router) => {
-    provide({
-        name: 'line',
-        description: 'LINE Messaging API Endpoint Adapter',
-        mounted: async (p) => {
-            const adapter = new LineAdapter(p, router);
-            await adapter.start();
-            return adapter;
-        },
-        dispose: async (adapter) => {
-            await adapter.stop();
-        },
-    });
-});
-// L11: Register LINE-specific tools
-useContext('tool', 'line', (toolService, lineAdapter) => {
-    const accessToken = lineAdapter.endpoints.values().next().value?.$config?.channelAccessToken;
-    const apiBaseUrl = lineAdapter.endpoints.values().next().value?.$config?.apiBaseUrl || 'https://api.line.me';
-    const disposers = [];
-    disposers.push(toolService.addTool({
-        name: 'line_get_profile',
-        description: 'Get LINE user profile by userId',
-        parameters: {
-            type: 'object',
-            properties: {
-                userId: { type: 'string', description: 'LINE user ID (starts with U)' },
-            },
-            required: ['userId'],
-        },
-        execute: async ({ userId }) => {
-            if (!userId.startsWith('U')) {
-                throw new Error(`Invalid userId "${userId}": must start with U`);
-            }
-            const response = await fetch(`${apiBaseUrl}/v2/profile/${userId}`, {
-                headers: { 'Authorization': `Bearer ${accessToken}` },
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`LINE Profile API error ${response.status}: ${errorText}`);
-            }
-            return await response.json();
-        },
-    }));
-    disposers.push(toolService.addTool({
-        name: 'line_get_group_members',
-        description: 'Get LINE group member IDs',
-        parameters: {
-            type: 'object',
-            properties: {
-                groupId: { type: 'string', description: 'LINE group ID (starts with G)' },
-            },
-            required: ['groupId'],
-        },
-        execute: async ({ groupId }) => {
-            if (!groupId.startsWith('G')) {
-                throw new Error(`Invalid groupId "${groupId}": must start with G`);
-            }
-            const response = await fetch(`${apiBaseUrl}/v2/bot/group/${groupId}/members/ids`, {
-                headers: { 'Authorization': `Bearer ${accessToken}` },
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`LINE Group Members API error ${response.status}: ${errorText}`);
-            }
-            return await response.json();
-        },
-    }));
-    return () => {
-        for (const disposer of disposers)
-            disposer();
-    };
-});
-//# sourceMappingURL=index.js.map
+export { formatInboundContent, formatOutboundMessages, generateMessageId, isMessageEvent, isPostbackEvent, isValidLineRecipientId, normalizeWebhookPath, readTextBody, resolveChannel, resolveLineConfig, verifySignature, } from './protocol.js';
+export { LineEndpoint, } from './endpoint.js';
+export { registerLineWebhookRoutes, handleLineWebhookRequest, } from './webhook.js';
+export { LineClient, lineClient, } from './client.js';

package/lib/line-endpoint-commands.d.ts

@@ -0,0 +1 @@
+export declare const lineEndpointCommands: import("@zhin.js/adapter").EndpointCommands<Readonly<import("@zhin.js/command").CommandDefinition<unknown, unknown, import("@zhin.js/command").CommandMessage, string | undefined>>>;

package/lib/line-endpoint-commands.js

@@ -0,0 +1,17 @@
+/**
+ * `line.endpoint` 命令族：由 @zhin.js/adapter 的 createEndpointCommands 套件生成。
+ * commands/endpoint/ 下的 list / add / remove 直接默认导出这三项。
+ */
+import { createEndpointCommands } from 'zhin.js/adapter';
+import { defineCommand } from 'zhin.js/command';
+import { lineRuntimeStateToken } from './line-runtime-state.js';
+export const lineEndpointCommands = createEndpointCommands({
+    adapterKey: 'line',
+    adapterDisplayName: 'LINE',
+    fields: [
+        { key: 'channelSecret', required: true, env: true, description: 'LINE channel secret' },
+        { key: 'channelAccessToken', required: true, env: true, description: 'LINE channel access token' },
+    ],
+    running: (use) => use(lineRuntimeStateToken).endpoints.values(),
+    describeEntry: (entry) => `channelAccessToken: ${String(entry.channelAccessToken)}`,
+}, defineCommand);

package/lib/line-runtime-state.d.ts

@@ -0,0 +1 @@
+export declare const lineRuntimeStateToken: import("zhin.js").Token<import("@zhin.js/adapter").EndpointRuntimeState>;

package/lib/line-runtime-state.js

@@ -0,0 +1,6 @@
+/**
+ * LINE 插件实例的运行时状态：adapter create() 注册的 endpoint 列表。
+ * 由 plugin.ts setup() provide，adapter create 与 `line.endpoint` 命令共享（同一 owner generation）。
+ */
+import { defineEndpointRuntimeStateToken } from 'zhin.js/adapter';
+export const lineRuntimeStateToken = defineEndpointRuntimeStateToken('line');

package/lib/protocol.d.ts

@@ -0,0 +1,158 @@
+/**
+ * LINE Messaging API protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ */
+import type { IncomingMessage } from 'node:http';
+import type { ConversationRef } from '@zhin.js/im-contract';
+/** Plugin Runtime owner config (`plugins.<instanceKey>` / schema.json). */
+export interface LineAdapterConfig {
+    readonly id?: string;
+    readonly channelSecret?: string;
+    readonly channelAccessToken?: string;
+    readonly webhookPath?: string;
+    readonly apiBaseUrl?: string;
+    /** Transitional: legacy root `endpoints[]` with `context: line`. */
+    readonly endpoints?: ReadonlyArray<Partial<ResolvedLineConfig> & {
+        readonly context?: string;
+    }>;
+}
+export interface ResolvedLineConfig {
+    readonly context: 'line';
+    readonly id: string;
+    readonly channelSecret: string;
+    readonly channelAccessToken: string;
+    readonly webhookPath: string;
+    readonly apiBaseUrl: string;
+}
+export interface LineUser {
+    readonly userId: string;
+    readonly displayName?: string;
+    readonly pictureUrl?: string;
+    readonly statusMessage?: string;
+}
+export interface LineMessageEvent {
+    readonly type: 'message';
+    readonly replyToken: string;
+    readonly source: LineSource;
+    readonly timestamp: number;
+    readonly message: LineMessage;
+}
+export interface LineFollowEvent {
+    readonly type: 'follow';
+    readonly replyToken: string;
+    readonly source: LineSource;
+    readonly timestamp: number;
+}
+export interface LineUnfollowEvent {
+    readonly type: 'unfollow';
+    readonly source: LineSource;
+    readonly timestamp: number;
+}
+export interface LineJoinEvent {
+    readonly type: 'join';
+    readonly replyToken: string;
+    readonly source: LineSource;
+    readonly timestamp: number;
+}
+export interface LineLeaveEvent {
+    readonly type: 'leave';
+    readonly source: LineSource;
+    readonly timestamp: number;
+}
+export interface LinePostbackEvent {
+    readonly type: 'postback';
+    readonly replyToken: string;
+    readonly source: LineSource;
+    readonly timestamp: number;
+    readonly postback: {
+        readonly data: string;
+        readonly params?: Record<string, string>;
+    };
+}
+export type LineEvent = LineMessageEvent | LineFollowEvent | LineUnfollowEvent | LineJoinEvent | LineLeaveEvent | LinePostbackEvent;
+export interface LineSource {
+    readonly type: 'user' | 'group' | 'room';
+    readonly userId?: string;
+    readonly groupId?: string;
+    readonly roomId?: string;
+}
+export interface LineMessage {
+    readonly id: string;
+    readonly type: 'text' | 'image' | 'video' | 'audio' | 'file' | 'location' | 'sticker';
+    readonly text?: string;
+    readonly fileName?: string;
+    readonly fileSize?: number;
+    readonly title?: string;
+    readonly address?: string;
+    readonly latitude?: number;
+    readonly longitude?: number;
+    readonly packageId?: string;
+    readonly stickerId?: string;
+    readonly stickerResourceType?: string;
+    readonly duration?: number;
+}
+export interface LineWebhookBody {
+    readonly destination: string;
+    readonly events: readonly LineEvent[];
+}
+export interface LineReplyMessage {
+    readonly type: 'text' | 'image' | 'video' | 'audio' | 'location' | 'sticker' | 'flex';
+    readonly text?: string;
+    readonly originalContentUrl?: string;
+    readonly previewImageUrl?: string;
+    readonly packageId?: string;
+    readonly stickerId?: string;
+    readonly title?: string;
+    readonly address?: string;
+    readonly latitude?: number;
+    readonly longitude?: number;
+    readonly duration?: number;
+    readonly altText?: string;
+    readonly contents?: Record<string, unknown>;
+}
+export interface LineReplyRequest {
+    readonly replyToken: string;
+    readonly messages: readonly LineReplyMessage[];
+}
+export interface LinePushRequest {
+    readonly to: string;
+    readonly messages: readonly LineReplyMessage[];
+}
+export interface LineApiResponse {
+    readonly sentMessages?: ReadonlyArray<{
+        readonly id: string;
+        readonly quoteToken?: string;
+    }>;
+}
+export interface LineWireSegment {
+    readonly type: string;
+    readonly data?: Record<string, unknown>;
+}
+export interface LineChannel {
+    readonly channelType: 'private' | 'group' | 'channel';
+    readonly channelId: string;
+}
+export declare function resolveLineConfig(config?: LineAdapterConfig): ResolvedLineConfig;
+export declare function normalizeWebhookPath(path: string): string;
+export declare function isMessageEvent(event: LineEvent): event is LineMessageEvent;
+export declare function isLineLifecycleEvent(event: LineEvent): boolean;
+export declare function isPostbackEvent(event: LineEvent): event is LinePostbackEvent;
+export declare function resolveChannel(source: LineSource): LineChannel;
+/**
+ * 入站归一化 → ConversationRef：LINE user → private、group → group、room → channel。
+ * LINE 没有 guild/频道容器概念，无 parent；recipient id 前缀（U/G/R）自带场景信息。
+ */
+export declare function lineInboundConversation(endpointKey: string, source: LineSource): ConversationRef;
+export declare function generateMessageId(event: LineEvent): string;
+/** Build inbound text for OutboundMessageService.receive. */
+export declare function formatInboundContent(event: LineEvent): string;
+export declare function verifySignature(channelSecret: string, body: string, signature: string): boolean;
+export declare function isValidLineRecipientId(id: string): boolean;
+/**
+ * Wire-encode an already-rendered outbound payload into LINE Reply/Push messages.
+ * Segment canonicalization is intentionally not done here.
+ */
+export declare function formatOutboundMessages(payload: unknown): LineReplyMessage[];
+export declare function readTextBody(request: IncomingMessage, options?: {
+    readonly limit?: number;
+}): Promise<string>;

package/lib/protocol.js

@@ -0,0 +1,265 @@
+/**
+ * LINE Messaging API protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ */
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { isMediaRef } from '@zhin.js/core';
+import { formatCompact, getLogger } from '@zhin.js/logger';
+const logger = getLogger('line');
+export function resolveLineConfig(config = {}) {
+    const entry = config.endpoints?.find((item) => item.context === 'line');
+    const channelSecret = config.channelSecret
+        ?? entry?.channelSecret
+        ?? process.env.LINE_CHANNEL_SECRET;
+    const channelAccessToken = config.channelAccessToken
+        ?? entry?.channelAccessToken
+        ?? process.env.LINE_CHANNEL_ACCESS_TOKEN;
+    if (!channelSecret || !channelAccessToken) {
+        throw new TypeError('LINE adapter requires channelSecret + channelAccessToken (plugins.<key> or endpoints with context: line)');
+    }
+    const id = (typeof config.id === 'string' && config.id)
+        || (typeof entry?.id === 'string' && entry.id)
+        || process.env.LINE_BOT_NAME
+        || 'line-bot';
+    const webhookPath = normalizeWebhookPath(config.webhookPath ?? entry?.webhookPath ?? '/line/webhook');
+    const apiBaseUrl = (config.apiBaseUrl ?? entry?.apiBaseUrl ?? 'https://api.line.me').replace(/\/$/, '');
+    return {
+        context: 'line',
+        id,
+        channelSecret,
+        channelAccessToken,
+        webhookPath,
+        apiBaseUrl,
+    };
+}
+export function normalizeWebhookPath(path) {
+    const trimmed = path.trim() || '/line/webhook';
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+export function isMessageEvent(event) {
+    return event.type === 'message' && 'message' in event && event.message != null;
+}
+export function isLineLifecycleEvent(event) {
+    return event.type === 'follow'
+        || event.type === 'unfollow'
+        || event.type === 'join'
+        || event.type === 'leave';
+}
+export function isPostbackEvent(event) {
+    return event.type === 'postback' && 'postback' in event;
+}
+export function resolveChannel(source) {
+    switch (source.type) {
+        case 'user':
+            return { channelType: 'private', channelId: source.userId || '' };
+        case 'group':
+            return { channelType: 'group', channelId: source.groupId || '' };
+        case 'room':
+            return { channelType: 'channel', channelId: source.roomId || '' };
+        default:
+            return { channelType: 'private', channelId: '' };
+    }
+}
+/**
+ * 入站归一化 → ConversationRef：LINE user → private、group → group、room → channel。
+ * LINE 没有 guild/频道容器概念，无 parent；recipient id 前缀（U/G/R）自带场景信息。
+ */
+export function lineInboundConversation(endpointKey, source) {
+    const channel = resolveChannel(source);
+    return {
+        endpoint: { id: endpointKey, adapter: endpointKey.split('\0')[0] ?? endpointKey },
+        kind: channel.channelType,
+        id: channel.channelId,
+    };
+}
+export function generateMessageId(event) {
+    if (isMessageEvent(event) && event.message?.id)
+        return event.message.id;
+    return `${event.type}-${event.timestamp}`;
+}
+/** Build inbound text for OutboundMessageService.receive. */
+export function formatInboundContent(event) {
+    if (isMessageEvent(event)) {
+        const msg = event.message;
+        switch (msg.type) {
+            case 'text':
+                return msg.text || '';
+            case 'location':
+                return msg.address || `[location: ${msg.latitude},${msg.longitude}]`;
+            case 'image':
+                return '[image]';
+            case 'video':
+                return '[video]';
+            case 'audio':
+                return '[audio]';
+            case 'file':
+                return msg.fileName ? `[file: ${msg.fileName}]` : '[file]';
+            case 'sticker':
+                return `[sticker: ${msg.packageId}/${msg.stickerId}]`;
+            default:
+                return `[${msg.type}]`;
+        }
+    }
+    if (event.type === 'follow')
+        return '[follow]';
+    if (event.type === 'join')
+        return '[join]';
+    if (event.type === 'unfollow')
+        return '[unfollow]';
+    if (event.type === 'leave')
+        return '[leave]';
+    if (event.type === 'postback')
+        return `[postback: ${event.postback.data}]`;
+    return '';
+}
+export function verifySignature(channelSecret, body, signature) {
+    const hmac = createHmac('sha256', channelSecret);
+    hmac.update(body, 'utf-8');
+    const computedSignature = hmac.digest('base64');
+    const sigBuf = Buffer.from(signature);
+    const computedBuf = Buffer.from(computedSignature);
+    if (sigBuf.length !== computedBuf.length)
+        return false;
+    return timingSafeEqual(sigBuf, computedBuf);
+}
+export function isValidLineRecipientId(id) {
+    return /^[UGR]/.test(id);
+}
+function buildTextMessage(text) {
+    const truncated = text.length > 5000 ? `${text.slice(0, 4997)}...` : text;
+    return { type: 'text', text: truncated };
+}
+/**
+ * 解析 image/audio/video 段的投递源（canonical MediaRef 唯一来源）。
+ * LINE Messaging API 媒体消息仅消费远程 HTTPS URL（无上传通道），
+ * 因此只有 kind=url 可投递；base64 / path / file 一律 warn + 丢弃。
+ */
+function resolveMediaUrl(seg) {
+    const media = (seg.data ?? {}).media;
+    if (!isMediaRef(media)) {
+        logger.warn(formatCompact({
+            op: 'line_outbound_media_dropped',
+            type: seg.type,
+            reason: 'missing_media_ref',
+        }));
+        return undefined;
+    }
+    if (media.kind !== 'url') {
+        logger.warn(formatCompact({
+            op: 'line_outbound_media_dropped',
+            type: seg.type,
+            reason: 'unsupported_media_kind',
+            kind: media.kind,
+        }));
+        return undefined;
+    }
+    return media.value;
+}
+/**
+ * Wire-encode an already-rendered outbound payload into LINE Reply/Push messages.
+ * Segment canonicalization is intentionally not done here.
+ */
+export function formatOutboundMessages(payload) {
+    if (typeof payload === 'string') {
+        return [buildTextMessage(payload)];
+    }
+    const items = Array.isArray(payload)
+        ? payload
+        : payload && typeof payload === 'object' && 'type' in payload
+            ? [payload]
+            : [];
+    if (items.length === 0) {
+        const text = payload == null
+            ? ''
+            : typeof payload === 'object'
+                ? JSON.stringify(payload)
+                : String(payload);
+        return [buildTextMessage(text)];
+    }
+    const messages = [];
+    for (const item of items) {
+        if (typeof item === 'string') {
+            messages.push(buildTextMessage(item));
+            continue;
+        }
+        const data = item.data ?? {};
+        switch (item.type) {
+            case 'text':
+                messages.push(buildTextMessage(String(data.text ?? data.content ?? '')));
+                break;
+            case 'at':
+                if (data.id) {
+                    messages.push(buildTextMessage(`@${String(data.name || data.id)}`));
+                }
+                break;
+            case 'image': {
+                const url = resolveMediaUrl(item);
+                if (url) {
+                    messages.push({
+                        type: 'image',
+                        originalContentUrl: url,
+                        previewImageUrl: url,
+                    });
+                }
+                break;
+            }
+            case 'video': {
+                const url = resolveMediaUrl(item);
+                if (url) {
+                    messages.push({
+                        type: 'video',
+                        originalContentUrl: url,
+                        previewImageUrl: typeof data.previewUrl === 'string' ? data.previewUrl : url,
+                    });
+                }
+                break;
+            }
+            case 'audio': {
+                const url = resolveMediaUrl(item);
+                if (url) {
+                    messages.push({
+                        type: 'audio',
+                        originalContentUrl: url,
+                        duration: typeof data.duration === 'number' ? data.duration : 0,
+                    });
+                }
+                break;
+            }
+            case 'location':
+                messages.push({
+                    type: 'location',
+                    title: String(data.title || 'Location'),
+                    address: String(data.address || ''),
+                    latitude: typeof data.latitude === 'number' ? data.latitude : 0,
+                    longitude: typeof data.longitude === 'number' ? data.longitude : 0,
+                });
+                break;
+            case 'sticker':
+                messages.push({
+                    type: 'sticker',
+                    packageId: String(data.package_id || '1'),
+                    stickerId: String(data.sticker_id || '1'),
+                });
+                break;
+            default:
+                messages.push(buildTextMessage(`[${item.type}]`));
+        }
+    }
+    // LINE allows at most 5 messages per Reply/Push request.
+    return messages.slice(0, 5);
+}
+export async function readTextBody(request, options = {}) {
+    const limit = options.limit ?? 1_048_576;
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limit) {
+            request.destroy();
+            throw new Error(`Request body exceeds ${limit} bytes`);
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}

package/lib/side-event-dispatch.d.ts

@@ -0,0 +1,4 @@
+import type { EndpointEventEmitter } from 'zhin.js/adapter';
+import { type getAdapterLogger } from '@zhin.js/logger';
+import { type LineEvent } from './protocol.js';
+export declare function receiveLineSideEvent(emit: EndpointEventEmitter, endpointKey: string, configId: string, event: LineEvent, logger: ReturnType<typeof getAdapterLogger>): void;

package/lib/side-event-dispatch.js

@@ -0,0 +1,42 @@
+import { buildNotice, senderFromId } from '@zhin.js/core';
+import { formatCompact } from '@zhin.js/logger';
+import { isLineLifecycleEvent, lineInboundConversation, } from './protocol.js';
+function mapLineLifecycleParts(type) {
+    switch (type) {
+        case 'follow':
+            return { scene_type: 'friend', sub_type: 'increase' };
+        case 'unfollow':
+            return { scene_type: 'friend', sub_type: 'decrease' };
+        case 'join':
+            return { scene_type: 'group', sub_type: 'member_increase' };
+        case 'leave':
+            return { scene_type: 'group', sub_type: 'member_decrease' };
+        default:
+            return { scene_type: 'line', sub_type: type };
+    }
+}
+export function receiveLineSideEvent(emit, endpointKey, configId, event, logger) {
+    if (!isLineLifecycleEvent(event))
+        return;
+    const parts = mapLineLifecycleParts(event.type);
+    const conversation = lineInboundConversation(endpointKey, event.source);
+    const userId = event.source.userId || conversation.id;
+    void emit('notice.receive', buildNotice(event, {
+        $id: `line:${event.type}:${event.timestamp}:${userId}`,
+        $adapter: 'line',
+        $endpoint: configId,
+        $type: 'notice',
+        $scene_id: conversation.id,
+        $scene_type: parts.scene_type,
+        $sub_type: parts.sub_type,
+        $actor: senderFromId(userId),
+        $timestamp: event.timestamp,
+    })).catch((err) => {
+        logger.warn(formatCompact({
+            op: 'line_side_event_failed',
+            endpoint: configId,
+            event: event.type,
+            error: err instanceof Error ? err.message : String(err),
+        }));
+    });
+}

package/lib/webhook.d.ts

@@ -0,0 +1,13 @@
+/**
+ * LINE webhook HTTP: signature → parse → admit.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { HttpHost, HttpRouteRegistration } from '@zhin.js/host-http';
+import { type LineEvent, type ResolvedLineConfig } from './protocol.js';
+export interface LineWebhookHandler {
+    readonly config: ResolvedLineConfig;
+    readonly isOpen: boolean;
+    admit(event: LineEvent): void;
+}
+export declare function registerLineWebhookRoutes(http: HttpHost, handler: LineWebhookHandler): HttpRouteRegistration[];
+export declare function handleLineWebhookRequest(request: IncomingMessage, response: ServerResponse, handler: LineWebhookHandler): Promise<void>;

package/lib/webhook.js

@@ -0,0 +1,50 @@
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { readTextBody, verifySignature, } from './protocol.js';
+const logger = getLogger('line');
+export function registerLineWebhookRoutes(http, handler) {
+    const path = handler.config.webhookPath;
+    return [
+        http.route('POST', path, async (request, response) => {
+            await handleLineWebhookRequest(request, response, handler);
+        }, { summary: 'LINE Messaging API webhook', tags: ['line'] }),
+    ];
+}
+export async function handleLineWebhookRequest(request, response, handler) {
+    try {
+        const signature = request.headers['x-line-signature'];
+        const signatureValue = Array.isArray(signature) ? signature[0] : signature;
+        if (!signatureValue) {
+            response.writeHead(403, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'Missing signature' }));
+            return;
+        }
+        const rawBody = await readTextBody(request);
+        if (!verifySignature(handler.config.channelSecret, rawBody, signatureValue)) {
+            logger.warn(formatCompact({ op: 'webhook', ok: false, error: 'invalid signature' }));
+            response.writeHead(403, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'Invalid signature' }));
+            return;
+        }
+        let body;
+        try {
+            body = JSON.parse(rawBody);
+        }
+        catch {
+            response.writeHead(200, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'OK' }));
+            return;
+        }
+        if (handler.isOpen && Array.isArray(body.events)) {
+            for (const event of body.events) {
+                handler.admit(event);
+            }
+        }
+        response.writeHead(200, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify({ message: 'OK' }));
+    }
+    catch (error) {
+        logger.error('LINE webhook error:', error);
+        response.writeHead(200, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify({ message: 'OK' }));
+    }
+}