@poolzin/pool-bot 2026.2.17 → 2026.2.19

package/dist/line/flex-templates/schedule-cards.js

@@ -0,0 +1,399 @@
+import { attachFooterText } from "./common.js";
+function buildTitleSubtitleHeader(params) {
+    const { title, subtitle } = params;
+    const headerContents = [
+        {
+            type: "text",
+            text: title,
+            weight: "bold",
+            size: "xl",
+            color: "#111111",
+            wrap: true,
+        },
+    ];
+    if (subtitle) {
+        headerContents.push({
+            type: "text",
+            text: subtitle,
+            size: "sm",
+            color: "#888888",
+            margin: "sm",
+            wrap: true,
+        });
+    }
+    return headerContents;
+}
+function buildCardHeaderSections(headerContents) {
+    return [
+        {
+            type: "box",
+            layout: "vertical",
+            contents: headerContents,
+            paddingBottom: "lg",
+        },
+        {
+            type: "separator",
+            color: "#EEEEEE",
+        },
+    ];
+}
+function createMegaBubbleWithFooter(params) {
+    const bubble = {
+        type: "bubble",
+        size: "mega",
+        body: {
+            type: "box",
+            layout: "vertical",
+            contents: params.bodyContents,
+            paddingAll: "xl",
+            backgroundColor: "#FFFFFF",
+        },
+    };
+    if (params.footer) {
+        attachFooterText(bubble, params.footer);
+    }
+    return bubble;
+}
+/**
+ * Create a receipt/summary card (for orders, transactions, data tables)
+ *
+ * Editorial design: Clean table layout with alternating row backgrounds,
+ * prominent total section, and clear visual hierarchy.
+ */
+export function createReceiptCard(params) {
+    const { title, subtitle, items, total, footer } = params;
+    const itemRows = items.slice(0, 12).map((item, index) => ({
+        type: "box",
+        layout: "horizontal",
+        contents: [
+            {
+                type: "text",
+                text: item.name,
+                size: "sm",
+                color: item.highlight ? "#111111" : "#666666",
+                weight: item.highlight ? "bold" : "regular",
+                flex: 3,
+                wrap: true,
+            },
+            {
+                type: "text",
+                text: item.value,
+                size: "sm",
+                color: item.highlight ? "#06C755" : "#333333",
+                weight: item.highlight ? "bold" : "regular",
+                flex: 2,
+                align: "end",
+                wrap: true,
+            },
+        ],
+        paddingAll: "md",
+        backgroundColor: index % 2 === 0 ? "#FFFFFF" : "#FAFAFA",
+    }));
+    // Header section
+    const headerContents = buildTitleSubtitleHeader({ title, subtitle });
+    const bodyContents = [
+        ...buildCardHeaderSections(headerContents),
+        {
+            type: "box",
+            layout: "vertical",
+            contents: itemRows,
+            margin: "md",
+            cornerRadius: "md",
+            borderWidth: "light",
+            borderColor: "#EEEEEE",
+        },
+    ];
+    // Total section with emphasis
+    if (total) {
+        bodyContents.push({
+            type: "box",
+            layout: "horizontal",
+            contents: [
+                {
+                    type: "text",
+                    text: total.label,
+                    size: "lg",
+                    weight: "bold",
+                    color: "#111111",
+                    flex: 2,
+                },
+                {
+                    type: "text",
+                    text: total.value,
+                    size: "xl",
+                    weight: "bold",
+                    color: "#06C755",
+                    flex: 2,
+                    align: "end",
+                },
+            ],
+            margin: "xl",
+            paddingAll: "lg",
+            backgroundColor: "#F0FDF4",
+            cornerRadius: "lg",
+        });
+    }
+    return createMegaBubbleWithFooter({ bodyContents, footer });
+}
+/**
+ * Create a calendar event card (for meetings, appointments, reminders)
+ *
+ * Editorial design: Date as hero, strong typographic hierarchy,
+ * color-blocked zones, full text wrapping for readability.
+ */
+export function createEventCard(params) {
+    const { title, date, time, location, description, calendar, isAllDay, action } = params;
+    // Hero date block - the most important information
+    const dateBlock = {
+        type: "box",
+        layout: "vertical",
+        contents: [
+            {
+                type: "text",
+                text: date.toUpperCase(),
+                size: "sm",
+                weight: "bold",
+                color: "#06C755",
+                wrap: true,
+            },
+            {
+                type: "text",
+                text: isAllDay ? "ALL DAY" : (time ?? ""),
+                size: "xxl",
+                weight: "bold",
+                color: "#111111",
+                wrap: true,
+                margin: "xs",
+            },
+        ],
+        paddingBottom: "lg",
+        borderWidth: "none",
+    };
+    // If no time and not all day, hide the time display
+    if (!time && !isAllDay) {
+        dateBlock.contents = [
+            {
+                type: "text",
+                text: date,
+                size: "xl",
+                weight: "bold",
+                color: "#111111",
+                wrap: true,
+            },
+        ];
+    }
+    // Event title with accent bar
+    const titleBlock = {
+        type: "box",
+        layout: "horizontal",
+        contents: [
+            {
+                type: "box",
+                layout: "vertical",
+                contents: [],
+                width: "4px",
+                backgroundColor: "#06C755",
+                cornerRadius: "2px",
+            },
+            {
+                type: "box",
+                layout: "vertical",
+                contents: [
+                    {
+                        type: "text",
+                        text: title,
+                        size: "lg",
+                        weight: "bold",
+                        color: "#1a1a1a",
+                        wrap: true,
+                    },
+                    ...(calendar
+                        ? [
+                            {
+                                type: "text",
+                                text: calendar,
+                                size: "xs",
+                                color: "#888888",
+                                margin: "sm",
+                                wrap: true,
+                            },
+                        ]
+                        : []),
+                ],
+                flex: 1,
+                paddingStart: "lg",
+            },
+        ],
+        paddingTop: "lg",
+        paddingBottom: "lg",
+        borderWidth: "light",
+        borderColor: "#EEEEEE",
+    };
+    const bodyContents = [dateBlock, titleBlock];
+    // Details section (location + description) in subtle background
+    const hasDetails = location || description;
+    if (hasDetails) {
+        const detailItems = [];
+        if (location) {
+            detailItems.push({
+                type: "box",
+                layout: "horizontal",
+                contents: [
+                    {
+                        type: "text",
+                        text: "📍",
+                        size: "sm",
+                        flex: 0,
+                    },
+                    {
+                        type: "text",
+                        text: location,
+                        size: "sm",
+                        color: "#444444",
+                        margin: "md",
+                        flex: 1,
+                        wrap: true,
+                    },
+                ],
+                alignItems: "flex-start",
+            });
+        }
+        if (description) {
+            detailItems.push({
+                type: "text",
+                text: description,
+                size: "sm",
+                color: "#666666",
+                wrap: true,
+                margin: location ? "lg" : "none",
+            });
+        }
+        bodyContents.push({
+            type: "box",
+            layout: "vertical",
+            contents: detailItems,
+            margin: "lg",
+            paddingAll: "lg",
+            backgroundColor: "#F8F9FA",
+            cornerRadius: "lg",
+        });
+    }
+    return {
+        type: "bubble",
+        size: "mega",
+        body: {
+            type: "box",
+            layout: "vertical",
+            contents: bodyContents,
+            paddingAll: "xl",
+            backgroundColor: "#FFFFFF",
+            action,
+        },
+    };
+}
+/**
+ * Create a calendar agenda card showing multiple events
+ *
+ * Editorial timeline design: Time-focused left column with event details
+ * on the right. Visual accent bars indicate event priority/recency.
+ */
+export function createAgendaCard(params) {
+    const { title, subtitle, events, footer } = params;
+    // Header with title and optional subtitle
+    const headerContents = buildTitleSubtitleHeader({ title, subtitle });
+    // Event timeline items
+    const eventItems = events.slice(0, 6).map((event, index) => {
+        const isActive = event.isNow || index === 0;
+        const accentColor = isActive ? "#06C755" : "#E5E5E5";
+        // Time column (fixed width)
+        const timeColumn = {
+            type: "box",
+            layout: "vertical",
+            contents: [
+                {
+                    type: "text",
+                    text: event.time ?? "—",
+                    size: "sm",
+                    weight: isActive ? "bold" : "regular",
+                    color: isActive ? "#06C755" : "#666666",
+                    align: "end",
+                    wrap: true,
+                },
+            ],
+            width: "65px",
+            justifyContent: "flex-start",
+        };
+        // Accent dot
+        const dotColumn = {
+            type: "box",
+            layout: "vertical",
+            contents: [
+                {
+                    type: "box",
+                    layout: "vertical",
+                    contents: [],
+                    width: "10px",
+                    height: "10px",
+                    backgroundColor: accentColor,
+                    cornerRadius: "5px",
+                },
+            ],
+            width: "24px",
+            alignItems: "center",
+            justifyContent: "flex-start",
+            paddingTop: "xs",
+        };
+        // Event details column
+        const detailContents = [
+            {
+                type: "text",
+                text: event.title,
+                size: "md",
+                weight: "bold",
+                color: "#1a1a1a",
+                wrap: true,
+            },
+        ];
+        // Secondary info line
+        const secondaryParts = [];
+        if (event.location) {
+            secondaryParts.push(event.location);
+        }
+        if (event.calendar) {
+            secondaryParts.push(event.calendar);
+        }
+        if (secondaryParts.length > 0) {
+            detailContents.push({
+                type: "text",
+                text: secondaryParts.join(" · "),
+                size: "xs",
+                color: "#888888",
+                wrap: true,
+                margin: "xs",
+            });
+        }
+        const detailColumn = {
+            type: "box",
+            layout: "vertical",
+            contents: detailContents,
+            flex: 1,
+        };
+        return {
+            type: "box",
+            layout: "horizontal",
+            contents: [timeColumn, dotColumn, detailColumn],
+            margin: index > 0 ? "xl" : undefined,
+            alignItems: "flex-start",
+        };
+    });
+    const bodyContents = [
+        ...buildCardHeaderSections(headerContents),
+        {
+            type: "box",
+            layout: "vertical",
+            contents: eventItems,
+            paddingTop: "xl",
+        },
+    ];
+    return createMegaBubbleWithFooter({ bodyContents, footer });
+}

package/dist/line/flex-templates/types.js

@@ -0,0 +1 @@
+export {};

package/dist/line/webhook-node.js

@@ -0,0 +1,100 @@
+import { danger, logVerbose } from "../globals.js";
+import { isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText, } from "../infra/http-body.js";
+import { validateLineSignature } from "./signature.js";
+import { isLineWebhookVerificationRequest, parseLineWebhookBody } from "./webhook-utils.js";
+const LINE_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
+const LINE_WEBHOOK_BODY_TIMEOUT_MS = 30_000;
+export async function readLineWebhookRequestBody(req, maxBytes = LINE_WEBHOOK_MAX_BODY_BYTES) {
+    return await readRequestBodyWithLimit(req, {
+        maxBytes,
+        timeoutMs: LINE_WEBHOOK_BODY_TIMEOUT_MS,
+    });
+}
+export function createLineNodeWebhookHandler(params) {
+    const maxBodyBytes = params.maxBodyBytes ?? LINE_WEBHOOK_MAX_BODY_BYTES;
+    const readBody = params.readBody ?? readLineWebhookRequestBody;
+    return 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 readBody(req, maxBodyBytes);
+            const signature = req.headers["x-line-signature"];
+            // Parse once; we may need it for verification requests and for event processing.
+            const body = parseLineWebhookBody(rawBody);
+            // LINE webhook verification sends POST {"events":[]} without a
+            // signature header. Return 200 so the LINE Developers Console
+            // "Verify" button succeeds.
+            if (!signature || typeof signature !== "string") {
+                if (isLineWebhookVerificationRequest(body)) {
+                    logVerbose("line: webhook verification request (empty events, no signature) - 200 OK");
+                    res.statusCode = 200;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify({ status: "ok" }));
+                    return;
+                }
+                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, params.channelSecret)) {
+                logVerbose("line: webhook signature validation failed");
+                res.statusCode = 401;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: "Invalid signature" }));
+                return;
+            }
+            if (!body) {
+                res.statusCode = 400;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: "Invalid webhook payload" }));
+                return;
+            }
+            // 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 params.bot.handleWebhook(body).catch((err) => {
+                    params.runtime.error?.(danger(`line webhook handler failed: ${String(err)}`));
+                });
+            }
+        }
+        catch (err) {
+            if (isRequestBodyLimitError(err, "PAYLOAD_TOO_LARGE")) {
+                res.statusCode = 413;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: "Payload too large" }));
+                return;
+            }
+            if (isRequestBodyLimitError(err, "REQUEST_BODY_TIMEOUT")) {
+                res.statusCode = 408;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: requestBodyErrorToText("REQUEST_BODY_TIMEOUT") }));
+                return;
+            }
+            params.runtime.error?.(danger(`line webhook error: ${String(err)}`));
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ error: "Internal server error" }));
+            }
+        }
+    };
+}

package/dist/line/webhook-utils.js

@@ -0,0 +1,11 @@
+export function parseLineWebhookBody(rawBody) {
+    try {
+        return JSON.parse(rawBody);
+    }
+    catch {
+        return null;
+    }
+}
+export function isLineWebhookVerificationRequest(body) {
+    return !!body && Array.isArray(body.events) && body.events.length === 0;
+}

package/dist/logging/timestamps.js

@@ -0,0 +1,14 @@
+export function formatLocalIsoWithOffset(now) {
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const h = String(now.getHours()).padStart(2, "0");
+    const m = String(now.getMinutes()).padStart(2, "0");
+    const s = String(now.getSeconds()).padStart(2, "0");
+    const ms = String(now.getMilliseconds()).padStart(3, "0");
+    const tzOffset = now.getTimezoneOffset();
+    const tzSign = tzOffset <= 0 ? "+" : "-";
+    const tzHours = String(Math.floor(Math.abs(tzOffset) / 60)).padStart(2, "0");
+    const tzMinutes = String(Math.abs(tzOffset) % 60).padStart(2, "0");
+    return `${year}-${month}-${day}T${h}:${m}:${s}.${ms}${tzSign}${tzHours}:${tzMinutes}`;
+}

package/dist/markdown/whatsapp.js

@@ -0,0 +1,62 @@
+import { escapeRegExp } from "../utils.js";
+/**
+ * Convert standard Markdown formatting to WhatsApp-compatible markup.
+ *
+ * WhatsApp uses its own formatting syntax:
+ *   bold:          *text*
+ *   italic:        _text_
+ *   strikethrough: ~text~
+ *   monospace:     ```text```
+ *
+ * Standard Markdown uses:
+ *   bold:          **text** or __text__
+ *   italic:        *text* or _text_
+ *   strikethrough: ~~text~~
+ *   code:          `text` (inline) or ```text``` (block)
+ *
+ * The conversion preserves fenced code blocks and inline code,
+ * then converts bold and strikethrough markers.
+ */
+/** Placeholder tokens used during conversion to protect code spans. */
+const FENCE_PLACEHOLDER = "\x00FENCE";
+const INLINE_CODE_PLACEHOLDER = "\x00CODE";
+/**
+ * Convert standard Markdown bold/italic/strikethrough to WhatsApp formatting.
+ *
+ * Order of operations matters:
+ * 1. Protect fenced code blocks (```...```) — already WhatsApp-compatible
+ * 2. Protect inline code (`...`) — leave as-is
+ * 3. Convert **bold** → *bold* and __bold__ → *bold*
+ * 4. Convert ~~strike~~ → ~strike~
+ * 5. Restore protected spans
+ *
+ * Italic *text* and _text_ are left alone since WhatsApp uses _text_ for italic
+ * and single * is already WhatsApp bold — no conversion needed for single markers.
+ */
+export function markdownToWhatsApp(text) {
+    if (!text) {
+        return text;
+    }
+    // 1. Extract and protect fenced code blocks
+    const fences = [];
+    let result = text.replace(/```[\s\S]*?```/g, (match) => {
+        fences.push(match);
+        return `${FENCE_PLACEHOLDER}${fences.length - 1}`;
+    });
+    // 2. Extract and protect inline code
+    const inlineCodes = [];
+    result = result.replace(/`[^`\n]+`/g, (match) => {
+        inlineCodes.push(match);
+        return `${INLINE_CODE_PLACEHOLDER}${inlineCodes.length - 1}`;
+    });
+    // 3. Convert **bold** → *bold* and __bold__ → *bold*
+    result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+    result = result.replace(/__(.+?)__/g, "*$1*");
+    // 4. Convert ~~strikethrough~~ → ~strikethrough~
+    result = result.replace(/~~(.+?)~~/g, "~$1~");
+    // 5. Restore inline code
+    result = result.replace(new RegExp(`${escapeRegExp(INLINE_CODE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => inlineCodes[Number(idx)] ?? "");
+    // 6. Restore fenced code blocks
+    result = result.replace(new RegExp(`${escapeRegExp(FENCE_PLACEHOLDER)}(\\d+)`, "g"), (_, idx) => fences[Number(idx)] ?? "");
+    return result;
+}

package/dist/media/base64.js

@@ -0,0 +1,34 @@
+export function estimateBase64DecodedBytes(base64) {
+    // Avoid `trim()`/`replace()` here: they allocate a second (potentially huge) string.
+    // We only need a conservative decoded-size estimate to enforce budgets before Buffer.from(..., "base64").
+    let effectiveLen = 0;
+    for (let i = 0; i < base64.length; i += 1) {
+        const code = base64.charCodeAt(i);
+        // Treat ASCII control + space as whitespace; base64 decoders commonly ignore these.
+        if (code <= 0x20) {
+            continue;
+        }
+        effectiveLen += 1;
+    }
+    if (effectiveLen === 0) {
+        return 0;
+    }
+    let padding = 0;
+    // Find last non-whitespace char(s) to detect '=' padding without allocating/copying.
+    let end = base64.length - 1;
+    while (end >= 0 && base64.charCodeAt(end) <= 0x20) {
+        end -= 1;
+    }
+    if (end >= 0 && base64[end] === "=") {
+        padding = 1;
+        end -= 1;
+        while (end >= 0 && base64.charCodeAt(end) <= 0x20) {
+            end -= 1;
+        }
+        if (end >= 0 && base64[end] === "=") {
+            padding = 2;
+        }
+    }
+    const estimated = Math.floor((effectiveLen * 3) / 4) - padding;
+    return Math.max(0, estimated);
+}

package/dist/media/local-roots.js

@@ -0,0 +1,32 @@
+import os from "node:os";
+import path from "node:path";
+import { resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
+import { resolveStateDir } from "../config/paths.js";
+function buildMediaLocalRoots(stateDir) {
+    const resolvedStateDir = path.resolve(stateDir);
+    return [
+        os.tmpdir(),
+        path.join(resolvedStateDir, "media"),
+        path.join(resolvedStateDir, "agents"),
+        path.join(resolvedStateDir, "workspace"),
+        path.join(resolvedStateDir, "sandboxes"),
+    ];
+}
+export function getDefaultMediaLocalRoots() {
+    return buildMediaLocalRoots(resolveStateDir());
+}
+export function getAgentScopedMediaLocalRoots(cfg, agentId) {
+    const roots = buildMediaLocalRoots(resolveStateDir());
+    if (!agentId?.trim()) {
+        return roots;
+    }
+    const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+    if (!workspaceDir) {
+        return roots;
+    }
+    const normalizedWorkspaceDir = path.resolve(workspaceDir);
+    if (!roots.includes(normalizedWorkspaceDir)) {
+        roots.push(normalizedWorkspaceDir);
+    }
+    return roots;
+}

package/dist/media/outbound-attachment.js

@@ -0,0 +1,10 @@
+import { loadWebMedia } from "../web/media.js";
+import { saveMediaBuffer } from "./store.js";
+export async function resolveOutboundAttachmentFromUrl(mediaUrl, maxBytes, options) {
+    const media = await loadWebMedia(mediaUrl, {
+        maxBytes,
+        localRoots: options?.localRoots,
+    });
+    const saved = await saveMediaBuffer(media.buffer, media.contentType ?? undefined, "outbound", maxBytes);
+    return { path: saved.path, contentType: saved.contentType };
+}