@poolzin/pool-bot 2026.2.21 → 2026.2.22

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

@@ -5,7 +5,7 @@ import { readSessionUpdatedAt, recordSessionMetaFromInbound, resolveStorePath, u
 import { logVerbose, shouldLogVerbose } from "../globals.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
 import { resolveAgentRoute } from "../routing/resolve-route.js";
-function getSourceInfo(source) {
+export function getLineSourceInfo(source) {
     const userId = source.type === "user"
         ? source.userId
         : source.type === "group"
@@ -30,6 +30,25 @@ function buildPeerId(source) {
     }
     return "unknown";
 }
+function resolveLineInboundRoute(params) {
+    recordChannelActivity({
+        channel: "line",
+        accountId: params.account.accountId,
+        direction: "inbound",
+    });
+    const { userId, groupId, roomId, isGroup } = getLineSourceInfo(params.source);
+    const peerId = buildPeerId(params.source);
+    const route = resolveAgentRoute({
+        cfg: params.cfg,
+        channel: "line",
+        accountId: params.account.accountId,
+        peer: {
+            kind: isGroup ? "group" : "direct",
+            id: peerId,
+        },
+    });
+    return { userId, groupId, roomId, isGroup, peerId, route };
+}
 // Common LINE sticker package descriptions
 const STICKER_PACKAGES = {
     "1": "Moon & James",
@@ -97,141 +116,172 @@ function extractMediaPlaceholder(message) {
             return "";
     }
 }
-export async function buildLineMessageContext(params) {
-    const { event, allMedia, cfg, account } = params;
-    recordChannelActivity({
-        channel: "line",
-        accountId: account.accountId,
-        direction: "inbound",
+function resolveLineConversationLabel(params) {
+    return params.isGroup
+        ? params.groupId
+            ? `group:${params.groupId}`
+            : params.roomId
+                ? `room:${params.roomId}`
+                : "unknown-group"
+        : params.senderLabel;
+}
+function resolveLineAddresses(params) {
+    const fromAddress = params.isGroup
+        ? params.groupId
+            ? `line:group:${params.groupId}`
+            : params.roomId
+                ? `line:room:${params.roomId}`
+                : `line:${params.peerId}`
+        : `line:${params.userId ?? params.peerId}`;
+    const toAddress = params.isGroup ? fromAddress : `line:${params.userId ?? params.peerId}`;
+    const originatingTo = params.isGroup ? fromAddress : `line:${params.userId ?? params.peerId}`;
+    return { fromAddress, toAddress, originatingTo };
+}
+async function finalizeLineInboundContext(params) {
+    const { fromAddress, toAddress, originatingTo } = resolveLineAddresses({
+        isGroup: params.source.isGroup,
+        groupId: params.source.groupId,
+        roomId: params.source.roomId,
+        userId: params.source.userId,
+        peerId: params.source.peerId,
     });
-    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 senderId = params.source.userId ?? "unknown";
+    const senderLabel = params.source.userId ? `user:${params.source.userId}` : "unknown";
+    const conversationLabel = resolveLineConversationLabel({
+        isGroup: params.source.isGroup,
+        groupId: params.source.groupId,
+        roomId: params.source.roomId,
+        senderLabel,
     });
-    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 storePath = resolveStorePath(params.cfg.session?.store, {
+        agentId: params.route.agentId,
     });
-    const envelopeOptions = resolveEnvelopeFormatOptions(cfg);
+    const envelopeOptions = resolveEnvelopeFormatOptions(params.cfg);
     const previousTimestamp = readSessionUpdatedAt({
         storePath,
-        sessionKey: route.sessionKey,
+        sessionKey: params.route.sessionKey,
     });
     const body = formatInboundEnvelope({
         channel: "LINE",
         from: conversationLabel,
-        timestamp,
-        body: rawBody,
-        chatType: isGroup ? "group" : "direct",
+        timestamp: params.timestamp,
+        body: params.rawBody,
+        chatType: params.source.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,
+        BodyForAgent: params.rawBody,
+        RawBody: params.rawBody,
+        CommandBody: params.rawBody,
         From: fromAddress,
         To: toAddress,
-        SessionKey: route.sessionKey,
-        AccountId: route.accountId,
-        ChatType: isGroup ? "group" : "direct",
+        SessionKey: params.route.sessionKey,
+        AccountId: params.route.accountId,
+        ChatType: params.source.isGroup ? "group" : "direct",
         ConversationLabel: conversationLabel,
-        GroupSubject: isGroup ? (groupId ?? roomId) : undefined,
+        GroupSubject: params.source.isGroup
+            ? (params.source.groupId ?? params.source.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,
+        MessageSid: params.messageSid,
+        Timestamp: params.timestamp,
+        MediaPath: params.media.firstPath,
+        MediaType: params.media.firstContentType,
+        MediaUrl: params.media.firstPath,
+        MediaPaths: params.media.paths,
+        MediaUrls: params.media.paths,
+        MediaTypes: params.media.types,
+        ...params.locationContext,
         OriginatingChannel: "line",
         OriginatingTo: originatingTo,
     });
     void recordSessionMetaFromInbound({
         storePath,
-        sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+        sessionKey: ctxPayload.SessionKey ?? params.route.sessionKey,
         ctx: ctxPayload,
     }).catch((err) => {
         logVerbose(`line: failed updating session meta: ${String(err)}`);
     });
-    if (!isGroup) {
+    if (!params.source.isGroup) {
         await updateLastRoute({
             storePath,
-            sessionKey: route.mainSessionKey,
+            sessionKey: params.route.mainSessionKey,
             deliveryContext: {
                 channel: "line",
-                to: userId ?? peerId,
-                accountId: route.accountId,
+                to: params.source.userId ?? params.source.peerId,
+                accountId: params.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}"`);
+        const mediaInfo = params.verboseLog.kind === "inbound" && (params.verboseLog.mediaCount ?? 0) > 1
+            ? ` mediaCount=${params.verboseLog.mediaCount}`
+            : "";
+        const label = params.verboseLog.kind === "inbound" ? "line inbound" : "line postback";
+        logVerbose(`${label}: from=${ctxPayload.From} len=${body.length}${mediaInfo} preview="${preview}"`);
     }
+    return { ctxPayload, replyToken: params.event.replyToken };
+}
+export async function buildLineMessageContext(params) {
+    const { event, allMedia, cfg, account } = params;
+    const source = event.source;
+    const { userId, groupId, roomId, isGroup, peerId, route } = resolveLineInboundRoute({
+        source,
+        cfg,
+        account,
+    });
+    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;
+    }
+    let locationContext;
+    if (message.type === "location") {
+        const loc = message;
+        locationContext = toLocationContext({
+            latitude: loc.latitude,
+            longitude: loc.longitude,
+            name: loc.title,
+            address: loc.address,
+        });
+    }
+    const { ctxPayload } = await finalizeLineInboundContext({
+        cfg,
+        account,
+        event,
+        route,
+        source: { userId, groupId, roomId, isGroup, peerId },
+        rawBody,
+        timestamp,
+        messageSid: messageId,
+        media: {
+            firstPath: allMedia[0]?.path,
+            firstContentType: allMedia[0]?.contentType,
+            paths: allMedia.length > 0 ? allMedia.map((m) => m.path) : undefined,
+            types: allMedia.length > 0
+                ? allMedia.map((m) => m.contentType).filter(Boolean)
+                : undefined,
+        },
+        locationContext,
+        verboseLog: { kind: "inbound", mediaCount: allMedia.length },
+    });
     return {
         ctxPayload,
         event,
@@ -246,27 +296,17 @@ export async function buildLineMessageContext(params) {
 }
 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({
+    const { userId, groupId, roomId, isGroup, peerId, route } = resolveLineInboundRoute({
+        source,
         cfg,
-        channel: "line",
-        accountId: account.accountId,
-        peer: {
-            kind: isGroup ? "group" : "dm",
-            id: peerId,
-        },
+        account,
     });
     const timestamp = event.timestamp;
     const rawData = event.postback?.data?.trim() ?? "";
-    if (!rawData)
+    if (!rawData) {
         return null;
+    }
     let rawBody = rawData;
     if (rawData.includes("line.action=")) {
         const params = new URLSearchParams(rawData);
@@ -274,92 +314,24 @@ export async function buildLinePostbackContext(params) {
         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,
+    const messageSid = event.replyToken ? `postback:${event.replyToken}` : `postback:${timestamp}`;
+    const { ctxPayload } = await finalizeLineInboundContext({
+        cfg,
+        account,
+        event,
+        route,
+        source: { userId, groupId, roomId, isGroup, peerId },
+        rawBody,
         timestamp,
-        body: rawBody,
-        chatType: isGroup ? "group" : "direct",
-        sender: {
-            id: senderId,
+        messageSid,
+        media: {
+            firstPath: "",
+            firstContentType: undefined,
+            paths: undefined,
+            types: undefined,
         },
-        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,
+        verboseLog: { kind: "postback" },
     });
-    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,

package/dist/logging/subsystem.js

@@ -1,31 +1,35 @@
+import { inspect } from "node:util";
 import { Chalk } from "chalk";
 import { CHAT_CHANNEL_ORDER } from "../channels/registry.js";
+import { isVerbose } from "../globals.js";
 import { defaultRuntime } from "../runtime.js";
+import { clearActiveProgressLine } from "../terminal/progress-line.js";
 import { getConsoleSettings, shouldLogSubsystemToConsole } from "./console.js";
-import { isVerbose } from "../globals.js";
 import { levelToMinLevel } from "./levels.js";
-import { getChildLogger } from "./logger.js";
+import { getChildLogger, isFileLogLevelEnabled } from "./logger.js";
 import { loggingState } from "./state.js";
-import { clearActiveProgressLine } from "../terminal/progress-line.js";
 function shouldLogToConsole(level, settings) {
-    if (settings.level === "silent")
+    if (settings.level === "silent") {
         return false;
+    }
     const current = levelToMinLevel(level);
     const min = levelToMinLevel(settings.level);
     return current <= min;
 }
 function isRichConsoleEnv() {
     const term = (process.env.TERM ?? "").toLowerCase();
-    if (process.env.COLORTERM || process.env.TERM_PROGRAM)
+    if (process.env.COLORTERM || process.env.TERM_PROGRAM) {
         return true;
+    }
     return term.length > 0 && term !== "dumb";
 }
 function getColorForConsole() {
     const hasForceColor = typeof process.env.FORCE_COLOR === "string" &&
         process.env.FORCE_COLOR.trim().length > 0 &&
         process.env.FORCE_COLOR.trim() !== "0";
-    if (process.env.NO_COLOR && !hasForceColor)
+    if (process.env.NO_COLOR && !hasForceColor) {
         return new Chalk({ level: 0 });
+    }
     const hasTty = Boolean(process.stdout.isTTY || process.stderr.isTTY);
     return hasTty || isRichConsoleEnv() ? new Chalk({ level: 1 }) : new Chalk({ level: 0 });
 }
@@ -38,8 +42,9 @@ const SUBSYSTEM_MAX_SEGMENTS = 2;
 const CHANNEL_SUBSYSTEM_PREFIXES = new Set(CHAT_CHANNEL_ORDER);
 function pickSubsystemColor(color, subsystem) {
     const override = SUBSYSTEM_COLOR_OVERRIDES[subsystem];
-    if (override)
+    if (override) {
         return color[override];
+    }
     let hash = 0;
     for (let i = 0; i < subsystem.length; i += 1) {
         hash = (hash * 31 + subsystem.charCodeAt(i)) | 0;
@@ -55,8 +60,9 @@ function formatSubsystemForConsole(subsystem) {
         SUBSYSTEM_PREFIXES_TO_DROP.includes(parts[0])) {
         parts.shift();
     }
-    if (parts.length === 0)
+    if (parts.length === 0) {
         return original;
+    }
     if (CHANNEL_SUBSYSTEM_PREFIXES.has(parts[0])) {
         return parts[0];
     }
@@ -66,8 +72,9 @@ function formatSubsystemForConsole(subsystem) {
     return parts.join("/");
 }
 export function stripRedundantSubsystemPrefixForConsole(message, displaySubsystem) {
-    if (!displaySubsystem)
+    if (!displaySubsystem) {
         return message;
+    }
     // Common duplication: "[discord] discord: ..." (when a message manually includes the subsystem tag).
     if (message.startsWith("[")) {
         const closeIdx = message.indexOf("]");
@@ -75,25 +82,31 @@ export function stripRedundantSubsystemPrefixForConsole(message, displaySubsyste
             const bracketTag = message.slice(1, closeIdx);
             if (bracketTag.toLowerCase() === displaySubsystem.toLowerCase()) {
                 let i = closeIdx + 1;
-                while (message[i] === " ")
+                while (message[i] === " ") {
                     i += 1;
+                }
                 return message.slice(i);
             }
         }
     }
     const prefix = message.slice(0, displaySubsystem.length);
-    if (prefix.toLowerCase() !== displaySubsystem.toLowerCase())
+    if (prefix.toLowerCase() !== displaySubsystem.toLowerCase()) {
         return message;
+    }
     const next = message.slice(displaySubsystem.length, displaySubsystem.length + 1);
-    if (next !== ":" && next !== " ")
+    if (next !== ":" && next !== " ") {
         return message;
+    }
     let i = displaySubsystem.length;
-    while (message[i] === " ")
+    while (message[i] === " ") {
         i += 1;
-    if (message[i] === ":")
+    }
+    if (message[i] === ":") {
         i += 1;
-    while (message[i] === " ")
+    }
+    while (message[i] === " ") {
         i += 1;
+    }
     return message.slice(i);
 }
 function formatConsoleLine(opts) {
@@ -148,12 +161,14 @@ function writeConsoleLine(level, line) {
     }
 }
 function logToFile(fileLogger, level, message, meta) {
-    if (level === "silent")
+    if (level === "silent") {
         return;
+    }
     const safeLevel = level;
     const method = fileLogger[safeLevel];
-    if (typeof method !== "function")
+    if (typeof method !== "function") {
         return;
+    }
     if (meta && Object.keys(meta).length > 0) {
         method.call(fileLogger, meta, message);
     }
@@ -164,8 +179,9 @@ function logToFile(fileLogger, level, message, meta) {
 export function createSubsystemLogger(subsystem) {
     let fileLogger = null;
     const getFileLogger = () => {
-        if (!fileLogger)
+        if (!fileLogger) {
             fileLogger = getChildLogger({ subsystem });
+        }
         return fileLogger;
     };
     const emit = (level, message, meta) => {
@@ -180,10 +196,12 @@ export function createSubsystemLogger(subsystem) {
             fileMeta = Object.keys(rest).length > 0 ? rest : undefined;
         }
         logToFile(getFileLogger(), level, message, fileMeta);
-        if (!shouldLogToConsole(level, { level: consoleSettings.level }))
+        if (!shouldLogToConsole(level, { level: consoleSettings.level })) {
             return;
-        if (!shouldLogSubsystemToConsole(subsystem))
+        }
+        if (!shouldLogSubsystemToConsole(subsystem)) {
             return;
+        }
         const consoleMessage = consoleMessageOverride ?? message;
         if (!isVerbose() &&
             subsystem === "agent/embedded" &&
@@ -199,8 +217,23 @@ export function createSubsystemLogger(subsystem) {
         });
         writeConsoleLine(level, line);
     };
+    const isConsoleEnabled = (level) => {
+        const consoleSettings = getConsoleSettings();
+        return (shouldLogToConsole(level, { level: consoleSettings.level }) &&
+            shouldLogSubsystemToConsole(subsystem));
+    };
+    const isFileEnabled = (level) => isFileLogLevelEnabled(level);
     const logger = {
         subsystem,
+        isEnabled: (level, target = "any") => {
+            if (target === "console") {
+                return isConsoleEnabled(level);
+            }
+            if (target === "file") {
+                return isFileEnabled(level);
+            }
+            return isConsoleEnabled(level) || isFileEnabled(level);
+        },
         trace: (message, meta) => emit("trace", message, meta),
         debug: (message, meta) => emit("debug", message, meta),
         info: (message, meta) => emit("info", message, meta),
@@ -223,9 +256,13 @@ export function createSubsystemLogger(subsystem) {
     return logger;
 }
 export function runtimeForLogger(logger, exit = defaultRuntime.exit) {
+    const formatArgs = (...args) => args
+        .map((arg) => (typeof arg === "string" ? arg : inspect(arg)))
+        .join(" ")
+        .trim();
     return {
-        log: (message) => logger.info(message),
-        error: (message) => logger.error(message),
+        log: (...args) => logger.info(formatArgs(...args)),
+        error: (...args) => logger.error(formatArgs(...args)),
         exit,
     };
 }