@gguf/pigbot 0.0.1 → 0.0.3

package/dist/line/http-registry.js

@@ -0,0 +1,27 @@
+const lineHttpRoutes = new Map();
+export function normalizeLineWebhookPath(path) {
+    const trimmed = path?.trim();
+    if (!trimmed)
+        return "/line/webhook";
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+export function registerLineHttpHandler(params) {
+    const normalizedPath = normalizeLineWebhookPath(params.path);
+    if (lineHttpRoutes.has(normalizedPath)) {
+        const suffix = params.accountId ? ` for account "${params.accountId}"` : "";
+        params.log?.(`line: webhook path ${normalizedPath} already registered${suffix}`);
+        return () => { };
+    }
+    lineHttpRoutes.set(normalizedPath, params.handler);
+    return () => {
+        lineHttpRoutes.delete(normalizedPath);
+    };
+}
+export async function handleLineHttpRequest(req, res) {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const handler = lineHttpRoutes.get(url.pathname);
+    if (!handler)
+        return false;
+    await handler(req, res);
+    return true;
+}

package/dist/line/index.js

@@ -0,0 +1,19 @@
+export { createLineBot, createLineWebhookCallback, } from "./bot.js";
+export { monitorLineProvider, getLineRuntimeState, } from "./monitor.js";
+export { sendMessageLine, pushMessageLine, pushMessagesLine, replyMessageLine, createImageMessage, createLocationMessage, createFlexMessage, createQuickReplyItems, createTextMessageWithQuickReplies, showLoadingAnimation, getUserProfile, getUserDisplayName, pushImageMessage, pushLocationMessage, pushFlexMessage, pushTemplateMessage, pushTextMessageWithQuickReplies, } from "./send.js";
+export { startLineWebhook, createLineWebhookMiddleware, } from "./webhook.js";
+export { handleLineHttpRequest, registerLineHttpHandler, normalizeLineWebhookPath, } from "./http-registry.js";
+export { resolveLineAccount, listLineAccountIds, resolveDefaultLineAccountId, normalizeAccountId, DEFAULT_ACCOUNT_ID, } from "./accounts.js";
+export { probeLineBot } from "./probe.js";
+export { downloadLineMedia } from "./download.js";
+export { LineConfigSchema } from "./config-schema.js";
+export { buildLineMessageContext } from "./bot-message-context.js";
+export { handleLineWebhookEvents } from "./bot-handlers.js";
+// Flex Message templates
+export { createInfoCard, createListCard, createImageCard, createActionCard, createCarousel, createNotificationBubble, createReceiptCard, createEventCard, createMediaPlayerCard, createAppleTvRemoteCard, createDeviceControlCard, toFlexMessage, } from "./flex-templates.js";
+// Markdown to LINE conversion
+export { processLineMessage, hasMarkdownToConvert, stripMarkdown, extractMarkdownTables, extractCodeBlocks, extractLinks, convertTableToFlexBubble, convertCodeBlockToFlexBubble, convertLinksToFlexBubble, } from "./markdown-to-line.js";
+// Rich Menu operations
+export { createRichMenu, uploadRichMenuImage, setDefaultRichMenu, cancelDefaultRichMenu, getDefaultRichMenuId, linkRichMenuToUser, linkRichMenuToUsers, unlinkRichMenuFromUser, unlinkRichMenuFromUsers, getRichMenuIdOfUser, getRichMenuList, getRichMenu, deleteRichMenu, createRichMenuAlias, deleteRichMenuAlias, createGridLayout, messageAction, uriAction, postbackAction, datetimePickerAction, createDefaultMenuConfig, } from "./rich-menu.js";
+// Template messages (Button, Confirm, Carousel)
+export { createConfirmTemplate, createButtonTemplate, createTemplateCarousel, createCarouselColumn, createImageCarousel, createImageCarouselColumn, createYesNoConfirm, createButtonMenu, createLinkMenu, createProductCarousel, messageAction as templateMessageAction, uriAction as templateUriAction, postbackAction as templatePostbackAction, datetimePickerAction as templateDatetimePickerAction, } from "./template-messages.js";

package/dist/line/markdown-to-line.js

@@ -0,0 +1,346 @@
+import { createReceiptCard, toFlexMessage } from "./flex-templates.js";
+/**
+ * Regex patterns for markdown detection
+ */
+const MARKDOWN_TABLE_REGEX = /^\|(.+)\|[\r\n]+\|[-:\s|]+\|[\r\n]+((?:\|.+\|[\r\n]*)+)/gm;
+const MARKDOWN_CODE_BLOCK_REGEX = /```(\w*)\n([\s\S]*?)```/g;
+const MARKDOWN_LINK_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
+/**
+ * Detect and extract markdown tables from text
+ */
+export function extractMarkdownTables(text) {
+    const tables = [];
+    let textWithoutTables = text;
+    // Reset regex state
+    MARKDOWN_TABLE_REGEX.lastIndex = 0;
+    let match;
+    const matches = [];
+    while ((match = MARKDOWN_TABLE_REGEX.exec(text)) !== null) {
+        const fullMatch = match[0];
+        const headerLine = match[1];
+        const bodyLines = match[2];
+        const headers = parseTableRow(headerLine);
+        const rows = bodyLines
+            .trim()
+            .split(/[\r\n]+/)
+            .filter((line) => line.trim())
+            .map(parseTableRow);
+        if (headers.length > 0 && rows.length > 0) {
+            matches.push({
+                fullMatch,
+                table: { headers, rows },
+            });
+        }
+    }
+    // Remove tables from text in reverse order to preserve indices
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const { fullMatch, table } = matches[i];
+        tables.unshift(table);
+        textWithoutTables = textWithoutTables.replace(fullMatch, "");
+    }
+    return { tables, textWithoutTables };
+}
+/**
+ * Parse a single table row (pipe-separated values)
+ */
+function parseTableRow(row) {
+    return row
+        .split("|")
+        .map((cell) => cell.trim())
+        .filter((cell, index, arr) => {
+        // Filter out empty cells at start/end (from leading/trailing pipes)
+        if (index === 0 && cell === "")
+            return false;
+        if (index === arr.length - 1 && cell === "")
+            return false;
+        return true;
+    });
+}
+/**
+ * Convert a markdown table to a LINE Flex Message bubble
+ */
+export function convertTableToFlexBubble(table) {
+    const parseCell = (value) => {
+        const raw = value?.trim() ?? "";
+        if (!raw)
+            return { text: "-", bold: false, hasMarkup: false };
+        let hasMarkup = false;
+        const stripped = raw.replace(/\*\*(.+?)\*\*/g, (_, inner) => {
+            hasMarkup = true;
+            return String(inner);
+        });
+        const text = stripped.trim() || "-";
+        const bold = /^\*\*.+\*\*$/.test(raw);
+        return { text, bold, hasMarkup };
+    };
+    const headerCells = table.headers.map((header) => parseCell(header));
+    const rowCells = table.rows.map((row) => row.map((cell) => parseCell(cell)));
+    const hasInlineMarkup = headerCells.some((cell) => cell.hasMarkup) ||
+        rowCells.some((row) => row.some((cell) => cell.hasMarkup));
+    // For simple 2-column tables, use receipt card format
+    if (table.headers.length === 2 && !hasInlineMarkup) {
+        const items = rowCells.map((row) => ({
+            name: row[0]?.text ?? "-",
+            value: row[1]?.text ?? "-",
+        }));
+        return createReceiptCard({
+            title: headerCells.map((cell) => cell.text).join(" / "),
+            items,
+        });
+    }
+    // For multi-column tables, create a custom layout
+    const headerRow = {
+        type: "box",
+        layout: "horizontal",
+        contents: headerCells.map((cell) => ({
+            type: "text",
+            text: cell.text,
+            weight: "bold",
+            size: "sm",
+            color: "#333333",
+            flex: 1,
+            wrap: true,
+        })),
+        paddingBottom: "sm",
+    };
+    const dataRows = rowCells.slice(0, 10).map((row, rowIndex) => {
+        const rowContents = table.headers.map((_, colIndex) => {
+            const cell = row[colIndex] ?? { text: "-", bold: false, hasMarkup: false };
+            return {
+                type: "text",
+                text: cell.text,
+                size: "sm",
+                color: "#666666",
+                flex: 1,
+                wrap: true,
+                weight: cell.bold ? "bold" : undefined,
+            };
+        });
+        return {
+            type: "box",
+            layout: "horizontal",
+            contents: rowContents,
+            margin: rowIndex === 0 ? "md" : "sm",
+        };
+    });
+    return {
+        type: "bubble",
+        body: {
+            type: "box",
+            layout: "vertical",
+            contents: [headerRow, { type: "separator", margin: "sm" }, ...dataRows],
+            paddingAll: "lg",
+        },
+    };
+}
+/**
+ * Detect and extract code blocks from text
+ */
+export function extractCodeBlocks(text) {
+    const codeBlocks = [];
+    let textWithoutCode = text;
+    // Reset regex state
+    MARKDOWN_CODE_BLOCK_REGEX.lastIndex = 0;
+    let match;
+    const matches = [];
+    while ((match = MARKDOWN_CODE_BLOCK_REGEX.exec(text)) !== null) {
+        const fullMatch = match[0];
+        const language = match[1] || undefined;
+        const code = match[2];
+        matches.push({
+            fullMatch,
+            block: { language, code: code.trim() },
+        });
+    }
+    // Remove code blocks in reverse order
+    for (let i = matches.length - 1; i >= 0; i--) {
+        const { fullMatch, block } = matches[i];
+        codeBlocks.unshift(block);
+        textWithoutCode = textWithoutCode.replace(fullMatch, "");
+    }
+    return { codeBlocks, textWithoutCode };
+}
+/**
+ * Convert a code block to a LINE Flex Message bubble
+ */
+export function convertCodeBlockToFlexBubble(block) {
+    const titleText = block.language ? `Code (${block.language})` : "Code";
+    // Truncate very long code to fit LINE's limits
+    const displayCode = block.code.length > 2000 ? block.code.slice(0, 2000) + "\n..." : block.code;
+    return {
+        type: "bubble",
+        body: {
+            type: "box",
+            layout: "vertical",
+            contents: [
+                {
+                    type: "text",
+                    text: titleText,
+                    weight: "bold",
+                    size: "sm",
+                    color: "#666666",
+                },
+                {
+                    type: "box",
+                    layout: "vertical",
+                    contents: [
+                        {
+                            type: "text",
+                            text: displayCode,
+                            size: "xs",
+                            color: "#333333",
+                            wrap: true,
+                        },
+                    ],
+                    backgroundColor: "#F5F5F5",
+                    paddingAll: "md",
+                    cornerRadius: "md",
+                    margin: "sm",
+                },
+            ],
+            paddingAll: "lg",
+        },
+    };
+}
+/**
+ * Extract markdown links from text
+ */
+export function extractLinks(text) {
+    const links = [];
+    // Reset regex state
+    MARKDOWN_LINK_REGEX.lastIndex = 0;
+    let match;
+    while ((match = MARKDOWN_LINK_REGEX.exec(text)) !== null) {
+        links.push({
+            text: match[1],
+            url: match[2],
+        });
+    }
+    // Replace markdown links with just the text (for plain text output)
+    const textWithLinks = text.replace(MARKDOWN_LINK_REGEX, "$1");
+    return { links, textWithLinks };
+}
+/**
+ * Create a Flex Message with tappable link buttons
+ */
+export function convertLinksToFlexBubble(links) {
+    const buttons = links.slice(0, 4).map((link, index) => ({
+        type: "button",
+        action: {
+            type: "uri",
+            label: link.text.slice(0, 20), // LINE button label limit
+            uri: link.url,
+        },
+        style: index === 0 ? "primary" : "secondary",
+        margin: index > 0 ? "sm" : undefined,
+    }));
+    return {
+        type: "bubble",
+        body: {
+            type: "box",
+            layout: "vertical",
+            contents: [
+                {
+                    type: "text",
+                    text: "Links",
+                    weight: "bold",
+                    size: "md",
+                    color: "#333333",
+                },
+            ],
+            paddingAll: "lg",
+            paddingBottom: "sm",
+        },
+        footer: {
+            type: "box",
+            layout: "vertical",
+            contents: buttons,
+            paddingAll: "md",
+        },
+    };
+}
+/**
+ * Strip markdown formatting from text (for plain text output)
+ * Handles: bold, italic, strikethrough, headers, blockquotes, horizontal rules
+ */
+export function stripMarkdown(text) {
+    let result = text;
+    // Remove bold: **text** or __text__
+    result = result.replace(/\*\*(.+?)\*\*/g, "$1");
+    result = result.replace(/__(.+?)__/g, "$1");
+    // Remove italic: *text* or _text_ (but not already processed)
+    result = result.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "$1");
+    result = result.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, "$1");
+    // Remove strikethrough: ~~text~~
+    result = result.replace(/~~(.+?)~~/g, "$1");
+    // Remove headers: # Title, ## Title, etc.
+    result = result.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+    // Remove blockquotes: > text
+    result = result.replace(/^>\s?(.*)$/gm, "$1");
+    // Remove horizontal rules: ---, ***, ___
+    result = result.replace(/^[-*_]{3,}$/gm, "");
+    // Remove inline code: `code`
+    result = result.replace(/`([^`]+)`/g, "$1");
+    // Clean up extra whitespace
+    result = result.replace(/\n{3,}/g, "\n\n");
+    result = result.trim();
+    return result;
+}
+/**
+ * Main function: Process text for LINE output
+ * - Extracts tables → Flex Messages
+ * - Extracts code blocks → Flex Messages
+ * - Strips remaining markdown
+ * - Returns processed text + Flex Messages
+ */
+export function processLineMessage(text) {
+    const flexMessages = [];
+    let processedText = text;
+    // 1. Extract and convert tables
+    const { tables, textWithoutTables } = extractMarkdownTables(processedText);
+    processedText = textWithoutTables;
+    for (const table of tables) {
+        const bubble = convertTableToFlexBubble(table);
+        flexMessages.push(toFlexMessage("Table", bubble));
+    }
+    // 2. Extract and convert code blocks
+    const { codeBlocks, textWithoutCode } = extractCodeBlocks(processedText);
+    processedText = textWithoutCode;
+    for (const block of codeBlocks) {
+        const bubble = convertCodeBlockToFlexBubble(block);
+        flexMessages.push(toFlexMessage("Code", bubble));
+    }
+    // 3. Handle links - convert [text](url) to plain text for display
+    // (We could also create link buttons, but that can get noisy)
+    const { textWithLinks } = extractLinks(processedText);
+    processedText = textWithLinks;
+    // 4. Strip remaining markdown formatting
+    processedText = stripMarkdown(processedText);
+    return {
+        text: processedText,
+        flexMessages,
+    };
+}
+/**
+ * Check if text contains markdown that needs conversion
+ */
+export function hasMarkdownToConvert(text) {
+    // Check for tables
+    MARKDOWN_TABLE_REGEX.lastIndex = 0;
+    if (MARKDOWN_TABLE_REGEX.test(text))
+        return true;
+    // Check for code blocks
+    MARKDOWN_CODE_BLOCK_REGEX.lastIndex = 0;
+    if (MARKDOWN_CODE_BLOCK_REGEX.test(text))
+        return true;
+    // Check for other markdown patterns
+    if (/\*\*[^*]+\*\*/.test(text))
+        return true; // bold
+    if (/~~[^~]+~~/.test(text))
+        return true; // strikethrough
+    if (/^#{1,6}\s+/m.test(text))
+        return true; // headers
+    if (/^>\s+/m.test(text))
+        return true; // blockquotes
+    return false;
+}

package/dist/line/monitor.js

@@ -0,0 +1,266 @@
+import { danger, logVerbose } from "../globals.js";
+import { createLineBot } from "./bot.js";
+import { validateLineSignature } from "./signature.js";
+import { normalizePluginHttpPath } from "../plugins/http-path.js";
+import { registerPluginHttpRoute } from "../plugins/http-registry.js";
+import { replyMessageLine, showLoadingAnimation, getUserDisplayName, createQuickReplyItems, createTextMessageWithQuickReplies, pushTextMessageWithQuickReplies, pushMessageLine, pushMessagesLine, createFlexMessage, createImageMessage, createLocationMessage, } from "./send.js";
+import { buildTemplateMessageFromPayload } from "./template-messages.js";
+import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
+import { resolveEffectiveMessagesConfig } from "../agents/identity.js";
+import { chunkMarkdownText } from "../auto-reply/chunk.js";
+import { processLineMessage } from "./markdown-to-line.js";
+import { sendLineReplyChunks } from "./reply-chunks.js";
+import { deliverLineAutoReply } from "./auto-reply-delivery.js";
+// Track runtime state in memory (simplified version)
+const runtimeState = new Map();
+function recordChannelRuntimeState(params) {
+    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) {
+    return runtimeState.get(`line:${accountId}`);
+}
+async function readRequestBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+        req.on("error", reject);
+    });
+}
+function startLineLoadingKeepalive(params) {
+    const intervalMs = params.intervalMs ?? 18_000;
+    const loadingSeconds = params.loadingSeconds ?? 20;
+    let stopped = false;
+    const trigger = () => {
+        if (stopped)
+            return;
+        void showLoadingAnimation(params.userId, {
+            accountId: params.accountId,
+            loadingSeconds,
+        }).catch(() => { });
+    };
+    trigger();
+    const timer = setInterval(trigger, intervalMs);
+    return () => {
+        if (stopped)
+            return;
+        stopped = true;
+        clearInterval(timer);
+    };
+}
+export async function monitorLineProvider(opts) {
+    const { channelAccessToken, channelSecret, accountId, config, runtime, abortSignal, webhookPath, } = opts;
+    const resolvedAccountId = accountId ?? "default";
+    // Record starting state
+    recordChannelRuntimeState({
+        channel: "line",
+        accountId: resolvedAccountId,
+        state: {
+            running: true,
+            lastStartAt: Date.now(),
+        },
+    });
+    // Create the bot
+    const bot = createLineBot({
+        channelAccessToken,
+        channelSecret,
+        accountId,
+        runtime,
+        config,
+        onMessage: async (ctx) => {
+            if (!ctx)
+                return;
+            const { ctxPayload, replyToken, route } = ctx;
+            // Record inbound activity
+            recordChannelRuntimeState({
+                channel: "line",
+                accountId: resolvedAccountId,
+                state: {
+                    lastInboundAt: Date.now(),
+                },
+            });
+            const shouldShowLoading = Boolean(ctx.userId && !ctx.isGroup);
+            // Fetch display name for logging (non-blocking)
+            const displayNamePromise = ctx.userId
+                ? getUserDisplayName(ctx.userId, { accountId: ctx.accountId })
+                : Promise.resolve(ctxPayload.From);
+            // Show loading animation while processing (non-blocking, best-effort)
+            const stopLoading = shouldShowLoading
+                ? startLineLoadingKeepalive({ userId: ctx.userId, accountId: ctx.accountId })
+                : null;
+            const displayName = await displayNamePromise;
+            logVerbose(`line: received message from ${displayName} (${ctxPayload.From})`);
+            // Dispatch to auto-reply system for AI response
+            try {
+                const textLimit = 5000; // LINE max message length
+                let replyTokenUsed = false; // Track if we've used the one-time reply token
+                const { queuedFinal } = await dispatchReplyWithBufferedBlockDispatcher({
+                    ctx: ctxPayload,
+                    cfg: config,
+                    dispatcherOptions: {
+                        responsePrefix: resolveEffectiveMessagesConfig(config, route.agentId).responsePrefix,
+                        deliver: async (payload, _info) => {
+                            const lineData = payload.channelData?.line ?? {};
+                            // Show loading animation before each delivery (non-blocking)
+                            if (ctx.userId && !ctx.isGroup) {
+                                void showLoadingAnimation(ctx.userId, { accountId: ctx.accountId }).catch(() => { });
+                            }
+                            const { replyTokenUsed: nextReplyTokenUsed } = await deliverLineAutoReply({
+                                payload,
+                                lineData,
+                                to: ctxPayload.From,
+                                replyToken,
+                                replyTokenUsed,
+                                accountId: ctx.accountId,
+                                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)}`));
+                        },
+                    },
+                    replyOptions: {},
+                });
+                if (!queuedFinal) {
+                    logVerbose(`line: no response generated for message from ${ctxPayload.From}`);
+                }
+            }
+            catch (err) {
+                runtime.error?.(danger(`line: auto-reply failed: ${String(err)}`));
+                // Send error message to user
+                if (replyToken) {
+                    try {
+                        await replyMessageLine(replyToken, [{ type: "text", text: "Sorry, I encountered an error processing your message." }], { accountId: ctx.accountId });
+                    }
+                    catch (replyErr) {
+                        runtime.error?.(danger(`line: error reply failed: ${String(replyErr)}`));
+                    }
+                }
+            }
+            finally {
+                stopLoading?.();
+            }
+        },
+    });
+    // Register HTTP webhook handler
+    const normalizedPath = normalizePluginHttpPath(webhookPath, "/line/webhook") ?? "/line/webhook";
+    const unregisterHttp = registerPluginHttpRoute({
+        path: normalizedPath,
+        pluginId: "line",
+        accountId: resolvedAccountId,
+        log: (msg) => logVerbose(msg),
+        handler: async (req, res) => {
+            // Handle GET requests for webhook verification
+            if (req.method === "GET") {
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "text/plain");
+                res.end("OK");
+                return;
+            }
+            // Only accept POST requests
+            if (req.method !== "POST") {
+                res.statusCode = 405;
+                res.setHeader("Allow", "GET, POST");
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: "Method Not Allowed" }));
+                return;
+            }
+            try {
+                const rawBody = await readRequestBody(req);
+                const signature = req.headers["x-line-signature"];
+                // Validate signature
+                if (!signature || typeof signature !== "string") {
+                    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;
+                }
+                if (!validateLineSignature(rawBody, signature, channelSecret)) {
+                    logVerbose("line: webhook signature validation failed");
+                    res.statusCode = 401;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ error: "Invalid signature" }));
+                    return;
+                }
+                // Parse and process the webhook body
+                const body = JSON.parse(rawBody);
+                // Respond immediately with 200 to avoid LINE timeout
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ status: "ok" }));
+                // Process events asynchronously
+                if (body.events && body.events.length > 0) {
+                    logVerbose(`line: received ${body.events.length} webhook events`);
+                    await bot.handleWebhook(body).catch((err) => {
+                        runtime.error?.(danger(`line webhook handler failed: ${String(err)}`));
+                    });
+                }
+            }
+            catch (err) {
+                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" }));
+                }
+            }
+        },
+    });
+    logVerbose(`line: registered webhook handler at ${normalizedPath}`);
+    // Handle abort signal
+    const stopHandler = () => {
+        logVerbose(`line: stopping provider for account ${resolvedAccountId}`);
+        unregisterHttp();
+        recordChannelRuntimeState({
+            channel: "line",
+            accountId: resolvedAccountId,
+            state: {
+                running: false,
+                lastStopAt: Date.now(),
+            },
+        });
+    };
+    abortSignal?.addEventListener("abort", stopHandler);
+    return {
+        account: bot.account,
+        handleWebhook: bot.handleWebhook,
+        stop: () => {
+            stopHandler();
+            abortSignal?.removeEventListener("abort", stopHandler);
+        },
+    };
+}