@gguf/pigbot 0.0.1 → 0.0.2

package/dist/line/bot-handlers.js

@@ -0,0 +1,258 @@
+import { danger, logVerbose } from "../globals.js";
+import { resolvePairingIdLabel } from "../pairing/pairing-labels.js";
+import { buildPairingReply } from "../pairing/pairing-messages.js";
+import { readChannelAllowFromStore, upsertChannelPairingRequest, } from "../pairing/pairing-store.js";
+import { buildLineMessageContext, buildLinePostbackContext, } from "./bot-message-context.js";
+import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore } from "./bot-access.js";
+import { downloadLineMedia } from "./download.js";
+import { pushMessageLine, replyMessageLine } from "./send.js";
+function getSourceInfo(source) {
+    const userId = source.type === "user"
+        ? source.userId
+        : source.type === "group"
+            ? source.userId
+            : source.type === "room"
+                ? source.userId
+                : undefined;
+    const groupId = source.type === "group" ? source.groupId : undefined;
+    const roomId = source.type === "room" ? source.roomId : undefined;
+    const isGroup = source.type === "group" || source.type === "room";
+    return { userId, groupId, roomId, isGroup };
+}
+function resolveLineGroupConfig(params) {
+    const groups = params.config.groups ?? {};
+    if (params.groupId) {
+        return groups[params.groupId] ?? groups[`group:${params.groupId}`] ?? groups["*"];
+    }
+    if (params.roomId) {
+        return groups[params.roomId] ?? groups[`room:${params.roomId}`] ?? groups["*"];
+    }
+    return groups["*"];
+}
+async function sendLinePairingReply(params) {
+    const { senderId, replyToken, context } = params;
+    const { code, created } = await upsertChannelPairingRequest({
+        channel: "line",
+        id: senderId,
+    });
+    if (!created)
+        return;
+    logVerbose(`line pairing request sender=${senderId}`);
+    const idLabel = (() => {
+        try {
+            return resolvePairingIdLabel("line");
+        }
+        catch {
+            return "lineUserId";
+        }
+    })();
+    const text = buildPairingReply({
+        channel: "line",
+        idLine: `Your ${idLabel}: ${senderId}`,
+        code,
+    });
+    try {
+        if (replyToken) {
+            await replyMessageLine(replyToken, [{ type: "text", text }], {
+                accountId: context.account.accountId,
+                channelAccessToken: context.account.channelAccessToken,
+            });
+            return;
+        }
+    }
+    catch (err) {
+        logVerbose(`line pairing reply failed for ${senderId}: ${String(err)}`);
+    }
+    try {
+        await pushMessageLine(`line:${senderId}`, text, {
+            accountId: context.account.accountId,
+            channelAccessToken: context.account.channelAccessToken,
+        });
+    }
+    catch (err) {
+        logVerbose(`line pairing reply failed for ${senderId}: ${String(err)}`);
+    }
+}
+async function shouldProcessLineEvent(event, context) {
+    const { cfg, account } = context;
+    const { userId, groupId, roomId, isGroup } = getSourceInfo(event.source);
+    const senderId = userId ?? "";
+    const storeAllowFrom = await readChannelAllowFromStore("line").catch(() => []);
+    const effectiveDmAllow = normalizeAllowFromWithStore({
+        allowFrom: account.config.allowFrom,
+        storeAllowFrom,
+    });
+    const groupConfig = resolveLineGroupConfig({ config: account.config, groupId, roomId });
+    const groupAllowOverride = groupConfig?.allowFrom;
+    const fallbackGroupAllowFrom = account.config.allowFrom?.length
+        ? account.config.allowFrom
+        : undefined;
+    const groupAllowFrom = firstDefined(groupAllowOverride, account.config.groupAllowFrom, fallbackGroupAllowFrom);
+    const effectiveGroupAllow = normalizeAllowFromWithStore({
+        allowFrom: groupAllowFrom,
+        storeAllowFrom,
+    });
+    const dmPolicy = account.config.dmPolicy ?? "pairing";
+    const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
+    const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+    if (isGroup) {
+        if (groupConfig?.enabled === false) {
+            logVerbose(`Blocked line group ${groupId ?? roomId ?? "unknown"} (group disabled)`);
+            return false;
+        }
+        if (typeof groupAllowOverride !== "undefined") {
+            if (!senderId) {
+                logVerbose("Blocked line group message (group allowFrom override, no sender ID)");
+                return false;
+            }
+            if (!isSenderAllowed({ allow: effectiveGroupAllow, senderId })) {
+                logVerbose(`Blocked line group sender ${senderId} (group allowFrom override)`);
+                return false;
+            }
+        }
+        if (groupPolicy === "disabled") {
+            logVerbose("Blocked line group message (groupPolicy: disabled)");
+            return false;
+        }
+        if (groupPolicy === "allowlist") {
+            if (!senderId) {
+                logVerbose("Blocked line group message (no sender ID, groupPolicy: allowlist)");
+                return false;
+            }
+            if (!effectiveGroupAllow.hasEntries) {
+                logVerbose("Blocked line group message (groupPolicy: allowlist, no groupAllowFrom)");
+                return false;
+            }
+            if (!isSenderAllowed({ allow: effectiveGroupAllow, senderId })) {
+                logVerbose(`Blocked line group message from ${senderId} (groupPolicy: allowlist)`);
+                return false;
+            }
+        }
+        return true;
+    }
+    if (dmPolicy === "disabled") {
+        logVerbose("Blocked line sender (dmPolicy: disabled)");
+        return false;
+    }
+    const dmAllowed = dmPolicy === "open" || isSenderAllowed({ allow: effectiveDmAllow, senderId });
+    if (!dmAllowed) {
+        if (dmPolicy === "pairing") {
+            if (!senderId) {
+                logVerbose("Blocked line sender (dmPolicy: pairing, no sender ID)");
+                return false;
+            }
+            await sendLinePairingReply({
+                senderId,
+                replyToken: "replyToken" in event ? event.replyToken : undefined,
+                context,
+            });
+        }
+        else {
+            logVerbose(`Blocked line sender ${senderId || "unknown"} (dmPolicy: ${dmPolicy})`);
+        }
+        return false;
+    }
+    return true;
+}
+async function handleMessageEvent(event, context) {
+    const { cfg, account, runtime, mediaMaxBytes, processMessage } = context;
+    const message = event.message;
+    if (!(await shouldProcessLineEvent(event, context)))
+        return;
+    // Download media if applicable
+    const allMedia = [];
+    if (message.type === "image" || message.type === "video" || message.type === "audio") {
+        try {
+            const media = await downloadLineMedia(message.id, account.channelAccessToken, mediaMaxBytes);
+            allMedia.push({
+                path: media.path,
+                contentType: media.contentType,
+            });
+        }
+        catch (err) {
+            const errMsg = String(err);
+            if (errMsg.includes("exceeds") && errMsg.includes("limit")) {
+                logVerbose(`line: media exceeds size limit for message ${message.id}`);
+                // Continue without media
+            }
+            else {
+                runtime.error?.(danger(`line: failed to download media: ${errMsg}`));
+            }
+        }
+    }
+    const messageContext = await buildLineMessageContext({
+        event,
+        allMedia,
+        cfg,
+        account,
+    });
+    if (!messageContext) {
+        logVerbose("line: skipping empty message");
+        return;
+    }
+    await processMessage(messageContext);
+}
+async function handleFollowEvent(event, _context) {
+    const userId = event.source.type === "user" ? event.source.userId : undefined;
+    logVerbose(`line: user ${userId ?? "unknown"} followed`);
+    // Could implement welcome message here
+}
+async function handleUnfollowEvent(event, _context) {
+    const userId = event.source.type === "user" ? event.source.userId : undefined;
+    logVerbose(`line: user ${userId ?? "unknown"} unfollowed`);
+}
+async function handleJoinEvent(event, _context) {
+    const groupId = event.source.type === "group" ? event.source.groupId : undefined;
+    const roomId = event.source.type === "room" ? event.source.roomId : undefined;
+    logVerbose(`line: bot joined ${groupId ? `group ${groupId}` : `room ${roomId}`}`);
+}
+async function handleLeaveEvent(event, _context) {
+    const groupId = event.source.type === "group" ? event.source.groupId : undefined;
+    const roomId = event.source.type === "room" ? event.source.roomId : undefined;
+    logVerbose(`line: bot left ${groupId ? `group ${groupId}` : `room ${roomId}`}`);
+}
+async function handlePostbackEvent(event, context) {
+    const data = event.postback.data;
+    logVerbose(`line: received postback: ${data}`);
+    if (!(await shouldProcessLineEvent(event, context)))
+        return;
+    const postbackContext = await buildLinePostbackContext({
+        event,
+        cfg: context.cfg,
+        account: context.account,
+    });
+    if (!postbackContext)
+        return;
+    await context.processMessage(postbackContext);
+}
+export async function handleLineWebhookEvents(events, context) {
+    for (const event of events) {
+        try {
+            switch (event.type) {
+                case "message":
+                    await handleMessageEvent(event, context);
+                    break;
+                case "follow":
+                    await handleFollowEvent(event, context);
+                    break;
+                case "unfollow":
+                    await handleUnfollowEvent(event, context);
+                    break;
+                case "join":
+                    await handleJoinEvent(event, context);
+                    break;
+                case "leave":
+                    await handleLeaveEvent(event, context);
+                    break;
+                case "postback":
+                    await handlePostbackEvent(event, context);
+                    break;
+                default:
+                    logVerbose(`line: unhandled event type: ${event.type}`);
+            }
+        }
+        catch (err) {
+            context.runtime.error?.(danger(`line: event handler failed: ${String(err)}`));
+        }
+    }
+}

package/dist/line/bot-message-context.js

@@ -0,0 +1,374 @@
+import { formatInboundEnvelope, resolveEnvelopeFormatOptions } from "../auto-reply/envelope.js";
+import { finalizeInboundContext } from "../auto-reply/reply/inbound-context.js";
+import { formatLocationText, toLocationContext } from "../channels/location.js";
+import { readSessionUpdatedAt, recordSessionMetaFromInbound, resolveStorePath, updateLastRoute, } from "../config/sessions.js";
+import { logVerbose, shouldLogVerbose } from "../globals.js";
+import { recordChannelActivity } from "../infra/channel-activity.js";
+import { resolveAgentRoute } from "../routing/resolve-route.js";
+function getSourceInfo(source) {
+    const userId = source.type === "user"
+        ? source.userId
+        : source.type === "group"
+            ? source.userId
+            : source.type === "room"
+                ? source.userId
+                : undefined;
+    const groupId = source.type === "group" ? source.groupId : undefined;
+    const roomId = source.type === "room" ? source.roomId : undefined;
+    const isGroup = source.type === "group" || source.type === "room";
+    return { userId, groupId, roomId, isGroup };
+}
+function buildPeerId(source) {
+    if (source.type === "group" && source.groupId) {
+        return `group:${source.groupId}`;
+    }
+    if (source.type === "room" && source.roomId) {
+        return `room:${source.roomId}`;
+    }
+    if (source.type === "user" && source.userId) {
+        return source.userId;
+    }
+    return "unknown";
+}
+// Common LINE sticker package descriptions
+const STICKER_PACKAGES = {
+    "1": "Moon & James",
+    "2": "Cony & Brown",
+    "3": "Brown & Friends",
+    "4": "Moon Special",
+    "11537": "Cony",
+    "11538": "Brown",
+    "11539": "Moon",
+    "6136": "Cony's Happy Life",
+    "6325": "Brown's Life",
+    "6359": "Choco",
+    "6362": "Sally",
+    "6370": "Edward",
+    "789": "LINE Characters",
+};
+function describeStickerKeywords(sticker) {
+    // Use sticker keywords if available (LINE provides these for some stickers)
+    const keywords = sticker.keywords;
+    if (keywords && keywords.length > 0) {
+        return keywords.slice(0, 3).join(", ");
+    }
+    // Use sticker text if available
+    const stickerText = sticker.text;
+    if (stickerText) {
+        return stickerText;
+    }
+    return "";
+}
+function extractMessageText(message) {
+    if (message.type === "text") {
+        return message.text;
+    }
+    if (message.type === "location") {
+        const loc = message;
+        return (formatLocationText({
+            latitude: loc.latitude,
+            longitude: loc.longitude,
+            name: loc.title,
+            address: loc.address,
+        }) ?? "");
+    }
+    if (message.type === "sticker") {
+        const sticker = message;
+        const packageName = STICKER_PACKAGES[sticker.packageId] ?? "sticker";
+        const keywords = describeStickerKeywords(sticker);
+        if (keywords) {
+            return `[Sent a ${packageName} sticker: ${keywords}]`;
+        }
+        return `[Sent a ${packageName} sticker]`;
+    }
+    return "";
+}
+function extractMediaPlaceholder(message) {
+    switch (message.type) {
+        case "image":
+            return "<media:image>";
+        case "video":
+            return "<media:video>";
+        case "audio":
+            return "<media:audio>";
+        case "file":
+            return "<media:document>";
+        default:
+            return "";
+    }
+}
+export async function buildLineMessageContext(params) {
+    const { event, allMedia, cfg, account } = params;
+    recordChannelActivity({
+        channel: "line",
+        accountId: account.accountId,
+        direction: "inbound",
+    });
+    const source = event.source;
+    const { userId, groupId, roomId, isGroup } = getSourceInfo(source);
+    const peerId = buildPeerId(source);
+    const route = resolveAgentRoute({
+        cfg,
+        channel: "line",
+        accountId: account.accountId,
+        peer: {
+            kind: isGroup ? "group" : "dm",
+            id: peerId,
+        },
+    });
+    const message = event.message;
+    const messageId = message.id;
+    const timestamp = event.timestamp;
+    // Build message body
+    const textContent = extractMessageText(message);
+    const placeholder = extractMediaPlaceholder(message);
+    let rawBody = textContent || placeholder;
+    if (!rawBody && allMedia.length > 0) {
+        rawBody = `<media:image>${allMedia.length > 1 ? ` (${allMedia.length} images)` : ""}`;
+    }
+    if (!rawBody && allMedia.length === 0) {
+        return null;
+    }
+    // Build sender info
+    const senderId = userId ?? "unknown";
+    const senderLabel = userId ? `user:${userId}` : "unknown";
+    // Build conversation label
+    const conversationLabel = isGroup
+        ? groupId
+            ? `group:${groupId}`
+            : roomId
+                ? `room:${roomId}`
+                : "unknown-group"
+        : senderLabel;
+    const storePath = resolveStorePath(cfg.session?.store, {
+        agentId: route.agentId,
+    });
+    const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
+    const previousTimestamp = readSessionUpdatedAt({
+        storePath,
+        sessionKey: route.sessionKey,
+    });
+    const body = formatInboundEnvelope({
+        channel: "LINE",
+        from: conversationLabel,
+        timestamp,
+        body: rawBody,
+        chatType: isGroup ? "group" : "direct",
+        sender: {
+            id: senderId,
+        },
+        previousTimestamp,
+        envelope: envelopeOptions,
+    });
+    // Build location context if applicable
+    let locationContext;
+    if (message.type === "location") {
+        const loc = message;
+        locationContext = toLocationContext({
+            latitude: loc.latitude,
+            longitude: loc.longitude,
+            name: loc.title,
+            address: loc.address,
+        });
+    }
+    const fromAddress = isGroup
+        ? groupId
+            ? `line:group:${groupId}`
+            : roomId
+                ? `line:room:${roomId}`
+                : `line:${peerId}`
+        : `line:${userId ?? peerId}`;
+    const toAddress = isGroup ? fromAddress : `line:${userId ?? peerId}`;
+    const originatingTo = isGroup ? fromAddress : `line:${userId ?? peerId}`;
+    const ctxPayload = finalizeInboundContext({
+        Body: body,
+        RawBody: rawBody,
+        CommandBody: rawBody,
+        From: fromAddress,
+        To: toAddress,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: isGroup ? "group" : "direct",
+        ConversationLabel: conversationLabel,
+        GroupSubject: isGroup ? (groupId ?? roomId) : undefined,
+        SenderId: senderId,
+        Provider: "line",
+        Surface: "line",
+        MessageSid: messageId,
+        Timestamp: timestamp,
+        MediaPath: allMedia[0]?.path,
+        MediaType: allMedia[0]?.contentType,
+        MediaUrl: allMedia[0]?.path,
+        MediaPaths: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined,
+        MediaUrls: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined,
+        MediaTypes: allMedia.length > 0
+            ? allMedia.map((m) => m.contentType).filter(Boolean)
+            : undefined,
+        ...locationContext,
+        OriginatingChannel: "line",
+        OriginatingTo: originatingTo,
+    });
+    void recordSessionMetaFromInbound({
+        storePath,
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        ctx: ctxPayload,
+    }).catch((err) => {
+        logVerbose(`line: failed updating session meta: ${String(err)}`);
+    });
+    if (!isGroup) {
+        await updateLastRoute({
+            storePath,
+            sessionKey: route.mainSessionKey,
+            deliveryContext: {
+                channel: "line",
+                to: userId ?? peerId,
+                accountId: route.accountId,
+            },
+            ctx: ctxPayload,
+        });
+    }
+    if (shouldLogVerbose()) {
+        const preview = body.slice(0, 200).replace(/\n/g, "\\n");
+        const mediaInfo = allMedia.length > 1 ? ` mediaCount=${allMedia.length}` : "";
+        logVerbose(`line inbound: from=${ctxPayload.From} len=${body.length}${mediaInfo} preview="${preview}"`);
+    }
+    return {
+        ctxPayload,
+        event,
+        userId,
+        groupId,
+        roomId,
+        isGroup,
+        route,
+        replyToken: event.replyToken,
+        accountId: account.accountId,
+    };
+}
+export async function buildLinePostbackContext(params) {
+    const { event, cfg, account } = params;
+    recordChannelActivity({
+        channel: "line",
+        accountId: account.accountId,
+        direction: "inbound",
+    });
+    const source = event.source;
+    const { userId, groupId, roomId, isGroup } = getSourceInfo(source);
+    const peerId = buildPeerId(source);
+    const route = resolveAgentRoute({
+        cfg,
+        channel: "line",
+        accountId: account.accountId,
+        peer: {
+            kind: isGroup ? "group" : "dm",
+            id: peerId,
+        },
+    });
+    const timestamp = event.timestamp;
+    const rawData = event.postback?.data?.trim() ?? "";
+    if (!rawData)
+        return null;
+    let rawBody = rawData;
+    if (rawData.includes("line.action=")) {
+        const params = new URLSearchParams(rawData);
+        const action = params.get("line.action") ?? "";
+        const device = params.get("line.device");
+        rawBody = device ? `line action ${action} device ${device}` : `line action ${action}`;
+    }
+    const senderId = userId ?? "unknown";
+    const senderLabel = userId ? `user:${userId}` : "unknown";
+    const conversationLabel = isGroup
+        ? groupId
+            ? `group:${groupId}`
+            : roomId
+                ? `room:${roomId}`
+                : "unknown-group"
+        : senderLabel;
+    const storePath = resolveStorePath(cfg.session?.store, {
+        agentId: route.agentId,
+    });
+    const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
+    const previousTimestamp = readSessionUpdatedAt({
+        storePath,
+        sessionKey: route.sessionKey,
+    });
+    const body = formatInboundEnvelope({
+        channel: "LINE",
+        from: conversationLabel,
+        timestamp,
+        body: rawBody,
+        chatType: isGroup ? "group" : "direct",
+        sender: {
+            id: senderId,
+        },
+        previousTimestamp,
+        envelope: envelopeOptions,
+    });
+    const fromAddress = isGroup
+        ? groupId
+            ? `line:group:${groupId}`
+            : roomId
+                ? `line:room:${roomId}`
+                : `line:${peerId}`
+        : `line:${userId ?? peerId}`;
+    const toAddress = isGroup ? fromAddress : `line:${userId ?? peerId}`;
+    const originatingTo = isGroup ? fromAddress : `line:${userId ?? peerId}`;
+    const ctxPayload = finalizeInboundContext({
+        Body: body,
+        RawBody: rawBody,
+        CommandBody: rawBody,
+        From: fromAddress,
+        To: toAddress,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: isGroup ? "group" : "direct",
+        ConversationLabel: conversationLabel,
+        GroupSubject: isGroup ? (groupId ?? roomId) : undefined,
+        SenderId: senderId,
+        Provider: "line",
+        Surface: "line",
+        MessageSid: event.replyToken ? `postback:${event.replyToken}` : `postback:${timestamp}`,
+        Timestamp: timestamp,
+        MediaPath: "",
+        MediaType: undefined,
+        MediaUrl: "",
+        MediaPaths: undefined,
+        MediaUrls: undefined,
+        MediaTypes: undefined,
+        OriginatingChannel: "line",
+        OriginatingTo: originatingTo,
+    });
+    void recordSessionMetaFromInbound({
+        storePath,
+        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        ctx: ctxPayload,
+    }).catch((err) => {
+        logVerbose(`line: failed updating session meta: ${String(err)}`);
+    });
+    if (!isGroup) {
+        await updateLastRoute({
+            storePath,
+            sessionKey: route.mainSessionKey,
+            deliveryContext: {
+                channel: "line",
+                to: userId ?? peerId,
+                accountId: route.accountId,
+            },
+            ctx: ctxPayload,
+        });
+    }
+    if (shouldLogVerbose()) {
+        const preview = body.slice(0, 200).replace(/\n/g, "\\n");
+        logVerbose(`line postback: from=${ctxPayload.From} len=${body.length} preview="${preview}"`);
+    }
+    return {
+        ctxPayload,
+        event,
+        userId,
+        groupId,
+        roomId,
+        isGroup,
+        route,
+        replyToken: event.replyToken,
+        accountId: account.accountId,
+    };
+}

package/dist/line/bot.js

@@ -0,0 +1,48 @@
+import { loadConfig } from "../config/config.js";
+import { logVerbose } from "../globals.js";
+import { resolveLineAccount } from "./accounts.js";
+import { handleLineWebhookEvents } from "./bot-handlers.js";
+import { startLineWebhook } from "./webhook.js";
+export function createLineBot(opts) {
+    const runtime = opts.runtime ?? {
+        log: console.log,
+        error: console.error,
+        exit: (code) => {
+            throw new Error(`exit ${code}`);
+        },
+    };
+    const cfg = opts.config ?? loadConfig();
+    const account = resolveLineAccount({
+        cfg,
+        accountId: opts.accountId,
+    });
+    const mediaMaxBytes = (opts.mediaMaxMb ?? account.config.mediaMaxMb ?? 10) * 1024 * 1024;
+    const processMessage = opts.onMessage ??
+        (async () => {
+            logVerbose("line: no message handler configured");
+        });
+    const handleWebhook = async (body) => {
+        if (!body.events || body.events.length === 0) {
+            return;
+        }
+        await handleLineWebhookEvents(body.events, {
+            cfg,
+            account,
+            runtime,
+            mediaMaxBytes,
+            processMessage,
+        });
+    };
+    return {
+        handleWebhook,
+        account,
+    };
+}
+export function createLineWebhookCallback(bot, channelSecret, path = "/line/webhook") {
+    const { handler } = startLineWebhook({
+        channelSecret,
+        onEvents: bot.handleWebhook,
+        path,
+    });
+    return { path, handler };
+}