@rikaidev/yomi 0.2.6

package/dist/line/core/thrift/struct/writer.js

@@ -0,0 +1,189 @@
+/**
+ * TCompact struct writer.
+ */
+import { Buffer } from 'node:buffer';
+import { varint, zigzag, zigzag64 } from '../primitives/varint.js';
+const COMPACT_TYPE_BY_THRIFT_TYPE = {
+    3: 3,
+    6: 4,
+    8: 5,
+    10: 6,
+    11: 8,
+    12: 12,
+    13: 11,
+    14: 10,
+    15: 9,
+};
+/**
+ * Check whether a value is a Buffer instance.
+ *
+ * @param value - Candidate value.
+ * @returns True when the value is a Buffer.
+ */
+function isBufferLike(value) {
+    return Buffer.isBuffer(value);
+}
+/**
+ * Check whether a value looks like a struct field tuple array.
+ *
+ * @param value - Candidate value.
+ * @returns True when the value is a struct field tuple array.
+ */
+function isStructFieldTupleArray(value) {
+    return (Array.isArray(value) &&
+        value.every((item) => Array.isArray(item) && item.length === 3));
+}
+/**
+ * Write one compact field header.
+ *
+ * @param parts - Buffer accumulator.
+ * @param compactType - Compact wire type.
+ * @param delta - Delta from previous field ID.
+ * @param fieldId - Absolute field ID.
+ */
+function writeHeader(parts, compactType, delta, fieldId) {
+    parts.push(delta > 0 && delta <= 15
+        ? Buffer.from([(delta << 4) | compactType])
+        : Buffer.concat([Buffer.from([compactType]), zigzag(fieldId)]));
+}
+/**
+ * Write one TCompact MAP payload.
+ *
+ * @param parts - Buffer accumulator.
+ * @param value - Map tuple payload.
+ */
+function writeMap(parts, value) {
+    const [keyType, valueType, entriesObject] = value;
+    const compactMap = { 8: 5, 11: 8, 12: 12 };
+    const compactKeyType = compactMap[keyType] || keyType;
+    const compactValueType = compactMap[valueType] || valueType;
+    const entries = Object.entries(entriesObject);
+    parts.push(varint(entries.length));
+    if (entries.length > 0) {
+        parts.push(Buffer.from([(compactKeyType << 4) | compactValueType]));
+    }
+    for (const [key, item] of entries) {
+        if (keyType === 11) {
+            const encodedKey = Buffer.from(key, 'utf-8');
+            parts.push(varint(encodedKey.length), encodedKey);
+        }
+        else if (keyType === 8) {
+            parts.push(zigzag(Number(key)));
+        }
+        if (valueType === 11) {
+            const encodedValue = typeof item === 'string' ? Buffer.from(item, 'utf-8') : item;
+            parts.push(varint(encodedValue.length), encodedValue);
+        }
+        else if (valueType === 8) {
+            parts.push(zigzag(item));
+        }
+    }
+}
+/**
+ * Write one TCompact LIST payload.
+ *
+ * @param parts - Buffer accumulator.
+ * @param value - List tuple payload.
+ */
+function writeList(parts, value) {
+    const [elementType, items] = value;
+    const compactMap = { 8: 5, 11: 8, 12: 12 };
+    const compactElementType = compactMap[elementType] || elementType;
+    if (items.length < 15) {
+        parts.push(Buffer.from([(items.length << 4) | compactElementType]));
+    }
+    else {
+        parts.push(Buffer.from([0xf0 | compactElementType]), varint(items.length));
+    }
+    for (const item of items) {
+        if (elementType === 11) {
+            const encodedItem = typeof item === 'string'
+                ? Buffer.from(item, 'utf-8')
+                : isBufferLike(item)
+                    ? item
+                    : Buffer.alloc(0);
+            parts.push(varint(encodedItem.length), encodedItem);
+        }
+        else if (elementType === 8) {
+            parts.push(zigzag(Number(item)));
+        }
+    }
+}
+/**
+ * Write one primitive or composite thrift field value.
+ *
+ * @param parts - Buffer accumulator.
+ * @param type - Thrift field type ID.
+ * @param value - Field value.
+ */
+function writeFieldValue(parts, type, value) {
+    if (type === 3) {
+        parts.push(Buffer.from([value & 0xff]));
+        return;
+    }
+    if (type === 6 || type === 8) {
+        parts.push(zigzag(value));
+        return;
+    }
+    if (type === 10) {
+        parts.push(zigzag64(value));
+        return;
+    }
+    if (type === 11) {
+        const encodedValue = typeof value === 'string'
+            ? Buffer.from(value, 'utf-8')
+            : isBufferLike(value)
+                ? value
+                : Buffer.alloc(0);
+        parts.push(varint(encodedValue.length), encodedValue);
+        return;
+    }
+    if (type === 12) {
+        if (isStructFieldTupleArray(value) && value.length) {
+            parts.push(writeFieldsArray(value, { v: 0 }));
+        }
+        parts.push(Buffer.from([0]));
+        return;
+    }
+    if (type === 13) {
+        writeMap(parts, value);
+        return;
+    }
+    if (type === 15 || type === 14) {
+        // SET (14) is wire-identical to LIST (15) in TCompact — same header and
+        // element payload; only the field-header type nibble (set above) differs.
+        writeList(parts, value);
+    }
+}
+/**
+ * Recursively write field definitions into a TCompact struct body.
+ *
+ * @param fields - Array of [type, fieldId, value] tuples.
+ * @param lastFieldId - Mutable field ID tracker for delta encoding.
+ * @param lastFieldId.v - Last written field ID.
+ * @returns Serialized struct body.
+ */
+export function writeFieldsArray(fields, lastFieldId) {
+    const parts = [];
+    for (const field of fields) {
+        if (!field) {
+            continue;
+        }
+        const [type, fieldId, value] = field;
+        const delta = fieldId - lastFieldId.v;
+        if (type === 2) {
+            const compactType = value ? 1 : 2;
+            writeHeader(parts, compactType, delta, fieldId);
+            lastFieldId.v = fieldId;
+            continue;
+        }
+        const compactType = COMPACT_TYPE_BY_THRIFT_TYPE[type];
+        if (compactType === undefined) {
+            throw new Error(`Unsupported thrift type: ${type}`);
+        }
+        writeHeader(parts, compactType, delta, fieldId);
+        lastFieldId.v = fieldId;
+        writeFieldValue(parts, type, value);
+    }
+    return Buffer.concat(parts);
+}

package/dist/line/core/thrift/types.js

@@ -0,0 +1,23 @@
+/**
+ * Thrift types and constants
+ */
+export const THRIFT_TYPE = {
+    STOP: 0,
+    BOOL: 2,
+    BYTE: 3,
+    DOUBLE: 4,
+    I16: 6,
+    I32: 8,
+    I64: 10,
+    STRING: 11,
+    STRUCT: 12,
+    MAP: 13,
+    SET: 14,
+    LIST: 15,
+};
+export const MSG_TYPE = {
+    CALL: 1,
+    REPLY: 2,
+    EXCEPTION: 3,
+    ONEWAY: 4,
+};

package/dist/line/core/video-thumbnail.js

@@ -0,0 +1,104 @@
+import { spawn } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+/** Longest edge of the generated poster, matching LINE's own video thumbnails. */
+const THUMBNAIL_MAX_EDGE = 384;
+/**
+ * Read a JPEG's pixel dimensions from its first Start-Of-Frame marker.
+ *
+ * MEDIA_THUMB_INFO must carry the poster's real width/height, and we produce
+ * the poster ourselves as JPEG, so a tiny dependency-free SOF parser avoids
+ * pulling in an image-decoding library. Returns null if no SOF marker is found.
+ *
+ * @param jpeg - JPEG bytes.
+ * @returns `{ width, height }`, or null when the markers can't be read.
+ */
+function readJpegDimensions(jpeg) {
+    // Skip the SOI (0xFFD8); then walk marker segments until a SOF marker.
+    let offset = 2;
+    while (offset + 9 < jpeg.length) {
+        if (jpeg[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+        const marker = jpeg[offset + 1];
+        // SOF0..SOF3, SOF5..SOF7, SOF9..SOF11, SOF13..SOF15 carry frame dimensions;
+        // the non-SOF markers in those ranges (DHT 0xC4, JPG 0xC8, DAC 0xCC) don't.
+        const isSof = marker >= 0xc0 &&
+            marker <= 0xcf &&
+            marker !== 0xc4 &&
+            marker !== 0xc8 &&
+            marker !== 0xcc;
+        if (isSof) {
+            const height = jpeg.readUInt16BE(offset + 5);
+            const width = jpeg.readUInt16BE(offset + 7);
+            return { width, height };
+        }
+        // Standalone markers (RSTn/SOI/EOI/TEM) have no length word; everything
+        // else is followed by a 2-byte segment length to skip past.
+        if ((marker >= 0xd0 && marker <= 0xd9) ||
+            marker === 0x01 ||
+            marker === 0xff) {
+            offset += 2;
+            continue;
+        }
+        const segmentLength = jpeg.readUInt16BE(offset + 2);
+        offset += 2 + segmentLength;
+    }
+    return null;
+}
+/**
+ * Extract a poster frame from a video, best-effort, using ffmpeg.
+ *
+ * Grabs the first frame, scaled to fit within {@link THUMBNAIL_MAX_EDGE} on the
+ * longest edge (aspect preserved), encoded as JPEG — the same shape LINE's own
+ * clients attach as a video's `__ud-preview`. Returns null (never throws) when
+ * ffmpeg is absent or fails, so the caller sends the video without a poster
+ * rather than not at all.
+ *
+ * @param videoBytes - Raw video bytes.
+ * @returns `{ jpeg, width, height }`, or null when no poster could be made.
+ */
+export async function extractVideoThumbnail(videoBytes) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'yomi-vthumb-'));
+    const inPath = path.join(dir, `in-${crypto.randomUUID()}`);
+    const outPath = path.join(dir, `out-${crypto.randomUUID()}.jpg`);
+    try {
+        await fs.writeFile(inPath, videoBytes);
+        await new Promise((resolve, reject) => {
+            const proc = spawn('ffmpeg', [
+                '-y',
+                '-i',
+                inPath,
+                '-frames:v',
+                '1',
+                '-vf',
+                `scale=${THUMBNAIL_MAX_EDGE}:${THUMBNAIL_MAX_EDGE}:force_original_aspect_ratio=decrease`,
+                '-f',
+                'mjpeg',
+                '-q:v',
+                '5',
+                outPath,
+            ], { stdio: ['ignore', 'ignore', 'ignore'] });
+            proc.on('error', reject);
+            proc.on('close', (code) => code === 0 ? resolve() : reject(new Error(`ffmpeg exited ${code}`)));
+        });
+        const jpeg = await fs.readFile(outPath);
+        if (jpeg.length === 0) {
+            return null;
+        }
+        const dims = readJpegDimensions(jpeg);
+        if (!dims) {
+            return null;
+        }
+        return { jpeg, width: dims.width, height: dims.height };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await fs.rm(dir, { force: true, recursive: true }).catch(() => { });
+    }
+}

package/dist/mcp/handlers/contacts.js

@@ -0,0 +1,166 @@
+import { createCliLogger } from '../../util/log.js';
+import { resolveUserNames } from '../names.js';
+import { jsonResult, toolError } from './shared.js';
+const log = createCliLogger('Yomi');
+/**
+ * Fetch and normalize the authenticated user's full friend list in one
+ * round trip: enumerate friend MIDs, then resolve them all through a
+ * single batched getContacts call. Also warms the shared nameCache so
+ * later tool calls (get_chat_messages, list_conversations) skip the
+ * network for these MIDs.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @returns Normalized friend contacts (unresolved names surfaced as null, never fabricated).
+ */
+async function fetchAllContacts(service) {
+    const mids = await service.client.getAllContactIds();
+    if (!Array.isArray(mids) || mids.length === 0) {
+        return [];
+    }
+    const contacts = await service.client.getContacts(mids);
+    const summaries = [];
+    for (const contact of contacts) {
+        if (!contact?.mid) {
+            continue;
+        }
+        if (contact.displayName) {
+            service.nameCache.set(contact.mid, contact.displayName);
+        }
+        summaries.push({
+            mid: contact.mid,
+            displayName: contact.displayName ?? null,
+        });
+    }
+    return summaries;
+}
+/**
+ * Handle `list_contacts` — the raw LINE friend list, straight from
+ * getAllContactIds + getContacts. No ranking, no scoring: whatever order
+ * LINE returns is what callers get.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @returns MCP tool result.
+ */
+export async function handleListContacts(service) {
+    const contacts = await fetchAllContacts(service);
+    return {
+        content: [
+            { type: 'text', text: JSON.stringify(contacts, null, 2) },
+        ],
+    };
+}
+/**
+ * Handle `find_contact` — case-insensitive substring match over the
+ * friend list's displayName, so a caller can resolve a person's name to
+ * the MID `send_message` needs for a 1:1. Pure lookup: no fuzzy scoring,
+ * no ranking by interaction history.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleFindContact(service, args) {
+    if (!args.name) {
+        return toolError('name is required.');
+    }
+    const needle = args.name.toLowerCase();
+    const contacts = await fetchAllContacts(service);
+    const matches = contacts.filter((contact) => contact.displayName?.toLowerCase().includes(needle));
+    return {
+        content: [
+            { type: 'text', text: JSON.stringify(matches, null, 2) },
+        ],
+    };
+}
+/**
+ * Handle `get_group_members` — the raw member list of one LINE group/room.
+ *
+ * Members come from getChats(withMembers): the chat's `extra` union carries
+ * the group-chat record at field 1, whose field 4 is a
+ * `{ memberMid: joinTimestamp }` map and field 5 the pending-invitation map.
+ * MIDs are resolved to display names via the shared batched/cached resolver.
+ * (getGroup returns null for these chats and is not used.)
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleGetGroupMembers(service, args) {
+    if (!args.chatId) {
+        return toolError('chatId is required.');
+    }
+    const chats = await service.client.getChats([args.chatId], true);
+    const chat = Array.isArray(chats) ? chats[0] : chats;
+    const groupExtra = chat?.extra?.['1'];
+    if (!groupExtra) {
+        return toolError(`No membership data for chatId "${args.chatId}" (not a group chat, or LINE returned no member list).`);
+    }
+    const memberMids = Object.keys(groupExtra['4'] ?? {});
+    const invitedMids = Object.keys(groupExtra['5'] ?? {});
+    const names = await resolveUserNames(service, [...memberMids, ...invitedMids]);
+    const summaries = [
+        ...memberMids.map((mid) => ({
+            mid,
+            displayName: names.get(mid) ?? null,
+            invited: false,
+        })),
+        ...invitedMids.map((mid) => ({
+            mid,
+            displayName: names.get(mid) ?? null,
+            invited: true,
+        })),
+    ];
+    return {
+        content: [
+            { type: 'text', text: JSON.stringify(summaries, null, 2) },
+        ],
+    };
+}
+/**
+ * Handle `add_friend` — REALLY adds a person to THIS account's LINE friends now
+ * by MID (TalkService findAndAddContactsByMid).
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleAddFriend(service, args) {
+    if (!args.mid) {
+        return toolError('mid is required.');
+    }
+    const result = await service.addFriend(args.mid);
+    log.info('add_friend.done', { mid: args.mid });
+    return jsonResult(result);
+}
+/**
+ * Handle `block_contact` — REALLY blocks a contact for THIS account now
+ * (TalkService blockContact). Reversible with unblock_contact.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleBlockContact(service, args) {
+    if (!args.mid) {
+        return toolError('mid is required.');
+    }
+    const result = await service.blockContact(args.mid);
+    log.info('block_contact.done', { mid: args.mid });
+    return jsonResult(result);
+}
+/**
+ * Handle `unblock_contact` — REALLY unblocks a previously blocked contact for
+ * THIS account now (TalkService unblockContact).
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleUnblockContact(service, args) {
+    if (!args.mid) {
+        return toolError('mid is required.');
+    }
+    const result = await service.unblockContact(args.mid);
+    log.info('unblock_contact.done', { mid: args.mid });
+    return jsonResult(result);
+}

package/dist/mcp/handlers/conversations.js

@@ -0,0 +1,193 @@
+import { decryptLineMessage } from '../../line/core/message-query-service.js';
+import { getExcludedChatIds } from '../../search/scope.js';
+import { createCliLogger } from '../../util/log.js';
+import { resolveLineMediaDescriptor, resolveLineMediaType } from '../media.js';
+import { resolveConversationNames, resolveSenderNames } from '../names.js';
+import { createPhiAccumulator, maskInto, phiNote } from '../phi-guard.js';
+import { toolError } from './shared.js';
+const log = createCliLogger('Yomi');
+/**
+ * Handle `list_conversations` — list LINE conversations (chats, groups, rooms)
+ * with unread counts, a last-message preview, and a resolved display name.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleListConversations(service, args) {
+    const result = await service.client.getMessageBoxes({
+        lastMessagesPerMessageBoxCount: 1,
+        messageBoxCountLimit: args.limit ?? 20,
+        withUnreadCount: true,
+    });
+    const boxes = result.messageBoxes || [];
+    const names = await resolveConversationNames(service, boxes.map((box) => box.id).filter(Boolean));
+    // The last message embedded in getMessageBoxes is E2EE-wrapped for most
+    // chats; run it through the same local decrypt path get_chat_messages
+    // uses so previews aren't silently empty. No extra network fetch per
+    // conversation — decryptLineMessage only resolves already-known/cached
+    // E2EE keys, the same cost paid whenever any message from that chat is
+    // decrypted.
+    const acc = createPhiAccumulator();
+    const conversations = await Promise.all(boxes.map(async (box) => {
+        const lastMessage = box.lastMessages?.[box.lastMessages.length - 1] || null;
+        const decryptedLastMessage = lastMessage
+            ? await decryptLineMessage(service.e2eeManager, lastMessage, box.id)
+            : null;
+        return {
+            id: box.id,
+            lastMessagePreview: maskInto(acc, decryptedLastMessage?.text ?? null),
+            name: names.get(box.id) ?? null,
+            unreadCount: box.unreadCount ?? 0,
+        };
+    }));
+    const content = [
+        { type: 'text', text: JSON.stringify(conversations, null, 2) },
+    ];
+    const note = phiNote(acc);
+    if (note)
+        content.push(note);
+    return { content };
+}
+/**
+ * Handle `get_chat_messages` — fetch messages from one conversation,
+ * E2EE-decrypted when key material is available, each with a resolved sender
+ * name; pages older history with `before`.
+ *
+ * Without `before`, returns the most recent `count` messages (unchanged
+ * behavior). With `before`, fetches exactly one page of messages older
+ * than that cursor via getPreviousMessagesV2WithRequest — no pagination
+ * loop, no bulk backfill.
+ *
+ * `mentions` is a deliberately read-only probe: LINE mentions are not in
+ * `text` (a plain `@name` there is just text, not a real mention — the
+ * actual mention data lives in `contentMetadata.MENTION`, already parsed
+ * per-message by parsers.ts). Nobody has verified MENTION's shape against
+ * a real payload, so it is passed through raw and unparsed rather than
+ * guessed at. This is the spec-gathering step; do not "finish" mentions by
+ * inventing a parsed shape or an outbound (send-a-mention) implementation
+ * from this alone — wait for an operator to observe the real payload
+ * against a live mentioning message first.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleGetChatMessages(service, args) {
+    if (!args.chatId) {
+        return toolError('chatId is required.');
+    }
+    const fetched = args.before
+        ? await service.getPreviousMessages(args.chatId, args.count ?? 50, args.before)
+        : await service.getRecentMessages(args.chatId, args.count ?? 50);
+    // LINE's getPreviousMessagesV2 treats endMessageId as INCLUSIVE, so the
+    // cursor message reappears at the top of each older page. Drop it so
+    // `before` returns strictly-older messages and callers can page without
+    // dedup.
+    const messages = args.before?.messageId
+        ? fetched.filter((message) => String(message.id) !== String(args.before?.messageId))
+        : fetched;
+    const names = await resolveSenderNames(service, messages.map((message) => message.from).filter(Boolean));
+    const acc = createPhiAccumulator();
+    const shaped = messages.map((message) => ({
+        createdTime: message.createdTime,
+        deliveredTime: message.deliveredTime,
+        from: message.from,
+        fromName: names.get(message.from) ?? null,
+        id: message.id,
+        mediaType: resolveLineMediaDescriptor(message) !== null
+            ? resolveLineMediaType(Number(message.contentType))
+            : null,
+        // Read-only probe (see JSDoc above `handleGetChatMessages`): raw,
+        // unparsed passthrough of contentMetadata.MENTION. Do not parse this
+        // into a structured shape here — its real format is unknown and must
+        // be observed against a live mentioning message before anyone builds
+        // the outbound (send-a-mention) side.
+        mentions: message.contentMetadata?.MENTION ?? null,
+        text: maskInto(acc, message.text),
+        e2eeDecrypted: message.e2eeDecrypted ?? null,
+        // Emitted ONLY when the message decrypted but could not be authenticated
+        // (LINE E2EE v1 — AES-CBC, no tag, no AAD), so its presence is a signal
+        // rather than noise on the ~98% of traffic that is v2 and verified.
+        ...(message.e2eeDecrypted && message.e2eeIntegrityVerified === false
+            ? { e2eeIntegrityVerified: false }
+            : {}),
+    }));
+    const content = [
+        { type: 'text', text: JSON.stringify(shaped, null, 2) },
+    ];
+    const note = phiNote(acc);
+    if (note)
+        content.push(note);
+    return { content };
+}
+/**
+ * Handle `mark_read` — explicitly send a LINE read receipt (sendChatChecked)
+ * for one conversation. This is the user-intent path; background capture and
+ * get_unread_digest never mark read. When messageId is omitted, marks read up
+ * to the latest message. Honest failure if nothing can be marked.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleMarkRead(service, args) {
+    if (!args.chatId) {
+        return toolError('chatId is required.');
+    }
+    const result = await service.markChatRead(args.chatId, args.messageId);
+    log.info('mark_read.done', { chatId: args.chatId, marked: result.marked });
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+/**
+ * Handle `get_unread_digest` — one-shot composite: every conversation with
+ * unread messages, each with its most recent messages, so a caller can
+ * summarize/triage in a single call instead of list_conversations + N
+ * get_chat_messages. Purely read-only: it never marks anything read and never
+ * touches the local search index. Denylist-excluded chats are omitted. No
+ * unread → empty list (honest, not fabricated).
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param args - Tool arguments.
+ * @returns MCP tool result.
+ */
+export async function handleGetUnreadDigest(service, args) {
+    const result = await service.client.getMessageBoxes({
+        lastMessagesPerMessageBoxCount: 1,
+        messageBoxCountLimit: args.limit ?? 20,
+        withUnreadCount: true,
+    });
+    const excluded = getExcludedChatIds();
+    const unreadBoxes = (result.messageBoxes || []).filter((box) => (box.unreadCount ?? 0) > 0 && box.id && !excluded.has(box.id));
+    const names = await resolveConversationNames(service, unreadBoxes.map((box) => box.id));
+    const perChat = args.perChat ?? 10;
+    const acc = createPhiAccumulator();
+    const digest = await Promise.all(unreadBoxes.map(async (box) => {
+        const messages = await service.getRecentMessages(box.id, perChat);
+        const senderNames = await resolveSenderNames(service, messages.map((m) => m.from).filter(Boolean));
+        return {
+            chatId: box.id,
+            name: names.get(box.id) ?? null,
+            unreadCount: box.unreadCount ?? 0,
+            messages: messages.map((m) => ({
+                createdTime: m.createdTime,
+                from: m.from,
+                fromName: senderNames.get(m.from) ?? null,
+                id: m.id,
+                mediaType: resolveLineMediaDescriptor(m) !== null
+                    ? resolveLineMediaType(Number(m.contentType))
+                    : null,
+                text: maskInto(acc, m.text),
+            })),
+        };
+    }));
+    const content = [
+        { type: 'text', text: JSON.stringify(digest, null, 2) },
+    ];
+    const note = phiNote(acc);
+    if (note)
+        content.push(note);
+    return { content };
+}