@rikaidev/yomi 0.5.0 → 0.6.0

package/dist/line/core/flex-message.js

@@ -1,3 +1,132 @@
+import { createHash } from 'node:crypto';
+function flexLayoutFingerprint(root) {
+    return createHash('sha256').update(JSON.stringify(root)).digest('hex');
+}
+const FLEX_METRIC = {
+    none: 0,
+    xxs: 2,
+    xs: 4,
+    sm: 6,
+    md: 8,
+    lg: 12,
+    xl: 16,
+    xxl: 20,
+};
+function resolveMetric(value, fallback = 0) {
+    if (typeof value !== 'string')
+        return fallback;
+    if (/^\d+(\.\d+)?px$/.test(value))
+        return Number(value.slice(0, -2));
+    return FLEX_METRIC[value] ?? fallback;
+}
+function resolveOptionalMetric(value) {
+    return typeof value === 'string' ? resolveMetric(value) : null;
+}
+function resolveDimension(value) {
+    if (typeof value !== 'string')
+        return { points: null, fraction: null };
+    if (/^\d+(\.\d+)?px$/.test(value))
+        return { points: Number(value.slice(0, -2)), fraction: null };
+    if (/^\d+(\.\d+)?%$/.test(value))
+        return { points: null, fraction: Number(value.slice(0, -1)) / 100 };
+    return { points: null, fraction: null };
+}
+function resolveFontSize(value) {
+    if (typeof value === 'string' && /^\d+(\.\d+)?px$/.test(value))
+        return Number(value.slice(0, -2));
+    const sizes = {
+        xxs: 10,
+        xs: 11,
+        sm: 12,
+        md: 13,
+        lg: 15,
+        xl: 18,
+        xxl: 22,
+        '3xl': 26,
+        '4xl': 30,
+        '5xl': 34,
+    };
+    return sizes[typeof value === 'string' ? value : 'md'] ?? 13;
+}
+function resolveAspectRatio(value) {
+    if (typeof value !== 'string')
+        return 1;
+    const [width, height] = value.split(':').map(Number);
+    return width > 0 && height > 0 ? width / height : 1;
+}
+function normalizeGradient(value) {
+    const raw = parseObject(value);
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const gradient = raw;
+    if (gradient.type !== 'linearGradient' ||
+        typeof gradient.startColor !== 'string' ||
+        typeof gradient.endColor !== 'string')
+        return null;
+    const angle = typeof gradient.angle === 'string'
+        ? Number(gradient.angle.replace(/deg$/, ''))
+        : 0;
+    const centerPosition = typeof gradient.centerPosition === 'string'
+        ? Number(gradient.centerPosition.replace(/%$/, '')) / 100
+        : null;
+    return {
+        type: 'linearGradient',
+        angle: Number.isFinite(angle) ? angle : 0,
+        startColor: gradient.startColor,
+        centerColor: typeof gradient.centerColor === 'string' ? gradient.centerColor : null,
+        endColor: gradient.endColor,
+        centerPosition: centerPosition !== null && Number.isFinite(centerPosition)
+            ? centerPosition
+            : null,
+    };
+}
+function resolveFlexStyle(node) {
+    const all = resolveMetric(node.paddingAll);
+    const width = resolveDimension(node.width);
+    const maxWidth = resolveDimension(node.maxWidth);
+    const height = resolveDimension(node.height);
+    const maxHeight = resolveDimension(node.maxHeight);
+    return {
+        axis: ['horizontal', 'vertical', 'baseline'].includes(node.layout)
+            ? node.layout
+            : null,
+        spacing: resolveMetric(node.spacing, 8),
+        paddingTop: resolveMetric(node.paddingTop, all),
+        paddingEnd: resolveMetric(node.paddingEnd, all),
+        paddingBottom: resolveMetric(node.paddingBottom, all),
+        paddingStart: resolveMetric(node.paddingStart, all),
+        marginBefore: resolveMetric(node.margin),
+        fontSize: resolveFontSize(node.size),
+        fontWeight: node.weight === 'bold' ? 700 : 400,
+        lineLimit: Number.isFinite(node.maxLines)
+            ? Number(node.maxLines)
+            : node.wrap === true
+                ? null
+                : 1,
+        aspectRatio: resolveAspectRatio(node.aspectRatio),
+        contentMode: node.aspectMode === 'cover' ? 'cover' : 'fit',
+        buttonStyle: node.style === 'primary' || node.style === 'secondary'
+            ? node.style
+            : 'link',
+        buttonHeight: node.height === 'sm' ? 34 : 40,
+        cornerRadius: resolveMetric(node.cornerRadius),
+        borderWidth: resolveMetric(node.borderWidth),
+        flexGrow: Number.isFinite(node.flex) ? Math.max(0, Number(node.flex)) : 0,
+        position: node.position === 'absolute' ? 'absolute' : 'relative',
+        offsetTop: resolveOptionalMetric(node.offsetTop),
+        offsetBottom: resolveOptionalMetric(node.offsetBottom),
+        offsetStart: resolveOptionalMetric(node.offsetStart),
+        offsetEnd: resolveOptionalMetric(node.offsetEnd),
+        widthPoints: width.points,
+        widthFraction: width.fraction,
+        maxWidthPoints: maxWidth.points,
+        maxWidthFraction: maxWidth.fraction,
+        heightPoints: height.points,
+        heightFraction: height.fraction,
+        maxHeightPoints: maxHeight.points,
+        maxHeightFraction: maxHeight.fraction,
+    };
+}
 const FLEX_PAYLOAD_KEYS = [
     'FLEX_JSON',
     'FLEX_CONTENTS',
@@ -31,6 +160,200 @@ function webUrl(value) {
         return null;
     }
 }
+export function resolveImagemapImageUrl(rawUrl, _canvasWidth, targetPixelWidth = 640) {
+    const base = webUrl(rawUrl);
+    if (!base)
+        return null;
+    const supported = [240, 300, 460, 700, 1040];
+    const requested = Math.max(1, targetPixelWidth);
+    const width = supported.find((candidate) => candidate >= requested) ??
+        supported[supported.length - 1];
+    const url = new URL(base);
+    if (!url.pathname.endsWith(`/${width}`)) {
+        url.pathname = `${url.pathname.replace(/\/$/, '')}/${width}`;
+    }
+    return url.toString();
+}
+function flexAction(raw) {
+    const parsed = parseObject(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const record = parsed;
+    const params = record.params && typeof record.params === 'object' ? record.params : record;
+    const rawType = String(record.type ?? '').toLowerCase();
+    const uri = webUrl(params.linkUri) || webUrl(record.uri);
+    const text = typeof params.text === 'string'
+        ? params.text
+        : typeof record.text === 'string'
+            ? record.text
+            : null;
+    const label = String(record.label ?? record.text ?? params.displayText ?? '').trim();
+    const data = typeof record.data === 'string'
+        ? record.data
+        : typeof params.data === 'string'
+            ? params.data
+            : null;
+    const type = rawType === 'web' || rawType === 'uri'
+        ? 'uri'
+        : rawType === 'message' || rawType === 'sendmessage'
+            ? 'message'
+            : rawType === 'postback'
+                ? 'postback'
+                : 'unknown';
+    return { type, label, uri, text, data };
+}
+function normalizeFlexNode(raw, depth = 0, block = null, blockStyle = null) {
+    if (depth > 24)
+        return null;
+    const parsed = parseObject(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const node = parsed;
+    const nodeType = String(node.type ?? 'box').toLowerCase();
+    const parsedBlockStyle = parseObject(blockStyle);
+    const inherited = parsedBlockStyle &&
+        typeof parsedBlockStyle === 'object' &&
+        !Array.isArray(parsedBlockStyle)
+        ? parsedBlockStyle
+        : {};
+    const childValues = Array.isArray(node.contents)
+        ? node.contents.map((child) => [child, null, null])
+        : ['header', 'hero', 'body', 'footer']
+            .filter((key) => Boolean(node[key]))
+            .map((key) => [node[key], key, node.styles?.[key]]);
+    if (node.altContent)
+        childValues.push([node.altContent, null, null]);
+    return {
+        type: nodeType,
+        block,
+        layout: typeof node.layout === 'string' ? node.layout : null,
+        text: typeof node.text === 'string' ? node.text : null,
+        url: webUrl(node.url) || webUrl(node.previewUrl),
+        color: typeof node.color === 'string' ? node.color : null,
+        backgroundColor: typeof node.backgroundColor === 'string'
+            ? node.backgroundColor
+            : typeof inherited.backgroundColor === 'string'
+                ? inherited.backgroundColor
+                : nodeType === 'bubble'
+                    ? '#FFFFFF'
+                    : null,
+        background: normalizeGradient(node.background),
+        size: typeof node.size === 'string' ? node.size : null,
+        weight: typeof node.weight === 'string' ? node.weight : null,
+        wrap: typeof node.wrap === 'boolean' ? node.wrap : null,
+        margin: typeof node.margin === 'string' ? node.margin : null,
+        spacing: typeof node.spacing === 'string' ? node.spacing : null,
+        paddingAll: typeof node.paddingAll === 'string' ? node.paddingAll : null,
+        paddingTop: typeof node.paddingTop === 'string' ? node.paddingTop : null,
+        paddingBottom: typeof node.paddingBottom === 'string' ? node.paddingBottom : null,
+        paddingStart: typeof node.paddingStart === 'string' ? node.paddingStart : null,
+        paddingEnd: typeof node.paddingEnd === 'string' ? node.paddingEnd : null,
+        style: typeof node.style === 'string' ? node.style : null,
+        height: typeof node.height === 'string' ? node.height : null,
+        width: typeof node.width === 'string' ? node.width : null,
+        maxWidth: typeof node.maxWidth === 'string' ? node.maxWidth : null,
+        maxHeight: typeof node.maxHeight === 'string' ? node.maxHeight : null,
+        justifyContent: typeof node.justifyContent === 'string' ? node.justifyContent : null,
+        alignItems: typeof node.alignItems === 'string' ? node.alignItems : null,
+        cornerRadius: typeof node.cornerRadius === 'string' ? node.cornerRadius : null,
+        borderColor: typeof node.borderColor === 'string' ? node.borderColor : null,
+        borderWidth: typeof node.borderWidth === 'string' ? node.borderWidth : null,
+        separator: inherited.separator === true,
+        separatorColor: typeof inherited.separatorColor === 'string'
+            ? inherited.separatorColor
+            : null,
+        maxLines: Number.isFinite(node.maxLines) ? Number(node.maxLines) : null,
+        decoration: typeof node.decoration === 'string' ? node.decoration : null,
+        position: typeof node.position === 'string' ? node.position : null,
+        offsetTop: typeof node.offsetTop === 'string' ? node.offsetTop : null,
+        offsetBottom: typeof node.offsetBottom === 'string' ? node.offsetBottom : null,
+        offsetStart: typeof node.offsetStart === 'string' ? node.offsetStart : null,
+        offsetEnd: typeof node.offsetEnd === 'string' ? node.offsetEnd : null,
+        resolved: resolveFlexStyle(node),
+        aspectRatio: typeof node.aspectRatio === 'string' ? node.aspectRatio : null,
+        aspectMode: node.aspectMode === 'fit' || node.aspectMode === 'cover'
+            ? node.aspectMode
+            : null,
+        align: typeof node.align === 'string' ? node.align : null,
+        gravity: typeof node.gravity === 'string' ? node.gravity : null,
+        flex: Number.isFinite(node.flex) ? Number(node.flex) : null,
+        action: flexAction(node.action),
+        children: childValues
+            .map(([child, childBlock, childStyle]) => normalizeFlexNode(child, depth + 1, childBlock, childStyle))
+            .filter((child) => Boolean(child)),
+    };
+}
+export function processFlexMessage(message) {
+    const metadata = message?.contentMetadata && typeof message.contentMetadata === 'object'
+        ? message.contentMetadata
+        : {};
+    const explicitAlt = typeof metadata.ALT_TEXT === 'string' ? metadata.ALT_TEXT : '';
+    const markup = parseObject(metadata.MARKUP_JSON);
+    if (markup && typeof markup === 'object' && !Array.isArray(markup)) {
+        const record = markup;
+        const canvas = record.canvas;
+        const scene = record.scenes?.[canvas?.initialScene];
+        if (canvas && scene && Array.isArray(scene.listeners)) {
+            const regions = scene.listeners.flatMap((listener) => {
+                const [x, y, width, height] = listener?.params ?? [];
+                const action = flexAction(record.actions?.[listener?.action]);
+                if (![x, y, width, height].every(Number.isFinite) || !action)
+                    return [];
+                return [{ x, y, width, height, action }];
+            });
+            return {
+                version: 1,
+                layoutVersion: 1,
+                layoutFingerprint: flexLayoutFingerprint(null),
+                kind: 'imagemap',
+                altText: explicitAlt,
+                width: Number(canvas.width) || null,
+                height: Number(canvas.height) || null,
+                imageUrl: resolveImagemapImageUrl(metadata.DOWNLOAD_URL, canvas.width),
+                regions,
+                root: null,
+            };
+        }
+    }
+    for (const key of FLEX_PAYLOAD_KEYS) {
+        if (key === 'MARKUP_JSON')
+            continue;
+        const parsed = parseObject(metadata[key]);
+        if (!parsed)
+            continue;
+        const root = normalizeFlexNode(parsed);
+        if (root) {
+            return {
+                version: 1,
+                layoutVersion: 1,
+                layoutFingerprint: flexLayoutFingerprint(root),
+                kind: 'flex',
+                altText: explicitAlt,
+                width: null,
+                height: null,
+                imageUrl: null,
+                regions: [],
+                root,
+            };
+        }
+    }
+    const textPayload = parseObject(message?.text);
+    const root = normalizeFlexNode(textPayload);
+    return root
+        ? {
+            version: 1,
+            layoutVersion: 1,
+            layoutFingerprint: flexLayoutFingerprint(root),
+            kind: 'flex',
+            altText: explicitAlt,
+            width: null,
+            height: null,
+            imageUrl: null,
+            regions: [],
+            root,
+        }
+        : null;
+}
 /** Interpret LINE bubble/carousel content in header→hero→body→footer order. */
 export function interpretFlexPayload(payload) {
     const texts = [];

package/dist/line/core/service.js

@@ -58,7 +58,6 @@ export class LineProtocolService extends EventEmitter {
     invalidateSession;
     tryRefreshToken;
     resumeSession;
-    resolveName;
     getContact;
     getGroup;
     listStickerPackages;

package/dist/mcp/handlers/contacts.js

@@ -1,5 +1,5 @@
 import { createCliLogger } from '../../util/log.js';
-import { resolveUserNames } from '../names.js';
+import { contactDisplayName, resolveUserNames } from '../names.js';
 import { jsonResult, toolError, toonResult } from './shared.js';
 const log = createCliLogger('Yomi');
 /**
@@ -23,12 +23,16 @@ async function fetchAllContacts(service) {
         if (!contact?.mid) {
             continue;
         }
-        if (contact.displayName) {
-            service.nameCache.set(contact.mid, contact.displayName);
+        const name = contactDisplayName(contact);
+        if (name) {
+            service.nameCache.set(contact.mid, name);
         }
         summaries.push({
             mid: contact.mid,
-            displayName: contact.displayName ?? null,
+            displayName: name,
+            ...(contact.displayNameOverridden && contact.displayName
+                ? { profileName: contact.displayName }
+                : {}),
         });
     }
     return summaries;
@@ -47,7 +51,8 @@ export async function handleListContacts(service) {
 }
 /**
  * Handle `find_contact` — case-insensitive substring match over the
- * friend list's displayName, so a caller can resolve a person's name to
+ * friend list's displayName (and profileName, when the user renamed the
+ * friend), 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.
  *
@@ -61,7 +66,8 @@ export async function handleFindContact(service, args) {
     }
     const needle = args.name.toLowerCase();
     const contacts = await fetchAllContacts(service);
-    const matches = contacts.filter((contact) => contact.displayName?.toLowerCase().includes(needle));
+    const matches = contacts.filter((contact) => contact.displayName?.toLowerCase().includes(needle) ||
+        contact.profileName?.toLowerCase().includes(needle));
     return toonResult(matches);
 }
 /**

package/dist/mcp/handlers/conversations.js

@@ -1,3 +1,4 @@
+import { isSquareChatMid } from '../../line/client/square-service/client.js';
 import { sanitizeMessagePreview } from '../../line/core/message-preview.js';
 import { decryptLineMessage } from '../../line/core/message-query-service.js';
 import { getExcludedChatIds } from '../../search/scope.js';
@@ -73,6 +74,38 @@ export async function handleListConversations(service, args) {
             unreadCount: box.unreadCount ?? 0,
         };
     }));
+    try {
+        const squareChats = await service.client.getJoinedSquareChats(args.limit ?? 20);
+        for (const chat of squareChats) {
+            let last = chat.lastMessage;
+            let senderName = chat.lastSenderName;
+            if (!last) {
+                const recent = await service.client.getSquareChatMessages(chat.id, 1);
+                const normalized = recent.at(-1);
+                if (normalized) {
+                    last = {
+                        4: normalized.id,
+                        5: normalized.createdTime,
+                        10: normalized.text,
+                        15: normalized.contentType,
+                    };
+                    senderName = normalized.fromName;
+                }
+            }
+            const preview = sanitizeMessagePreview(last?.[10]);
+            conversations.push({
+                id: chat.id,
+                lastMessagePreview: maskInto(acc, preview || (last ? '[社群訊息]' : null)),
+                name: maskInto(acc, chat.name),
+                unreadCount: chat.unreadCount,
+                ...(senderName ? { lastSenderName: maskInto(acc, senderName) } : {}),
+            });
+        }
+    }
+    catch {
+        // OpenChat availability differs by LINE account/region. TalkService
+        // conversations remain authoritative when SquareService is unavailable.
+    }
     const content = [
         { type: 'text', text: toonText(conversations) },
     ];
@@ -109,6 +142,27 @@ export async function handleGetChatMessages(service, args) {
     if (!args.chatId) {
         return toolError('chatId is required.');
     }
+    if (isSquareChatMid(args.chatId)) {
+        const squareMessages = await service.client.getSquareChatMessages(args.chatId, args.count ?? 50);
+        const acc = createPhiAccumulator();
+        const shaped = squareMessages.map((message) => ({
+            createdTime: message.createdTime,
+            deliveredTime: message.createdTime,
+            from: message.fromMid,
+            fromName: maskInto(acc, message.fromName),
+            id: message.id,
+            mediaType: resolveLineMediaType(Number(message.contentType)),
+            mentions: message.contentMetadata?.MENTION ?? null,
+            text: maskInto(acc, sanitizeMessagePreview(message.text) || '[社群訊息]'),
+            e2eeDecrypted: null,
+            service: 'SQUARE',
+        }));
+        const content = [{ type: 'text', text: toonText(shaped) }];
+        const note = phiNote(acc);
+        if (note)
+            content.push(note);
+        return { content };
+    }
     const fetched = args.before
         ? await service.getPreviousMessages(args.chatId, args.count ?? 50, args.before)
         : await service.getRecentMessages(args.chatId, args.count ?? 50);

package/dist/mcp/handlers/send.js

@@ -226,6 +226,11 @@ export async function handleSendFile(service, args) {
  * person's mid in contentMetadata. `displayName` is resolved from the mid when
  * the caller omits it. One send per call; honest error on failure.
  *
+ * The recipient reads this string, so it is always the contact's own profile
+ * name (contact-query field 22) and never the name a shared cache holds. That
+ * cache exists to show the user the name they gave a friend locally, which is
+ * a private label and must not travel to a third party.
+ *
  * @param service - Resumed LineProtocolService.
  * @param args - Tool arguments.
  * @returns MCP tool result.
@@ -240,19 +245,11 @@ export async function handleSendContact(service, args) {
     let displayName = args.displayName ?? '';
     if (!displayName) {
         try {
-            displayName = service.resolveName(args.contactMid) || '';
+            const contact = await service.getContact(args.contactMid);
+            displayName = contact?.displayName ?? '';
         }
         catch {
-            displayName = '';
-        }
-        if (!displayName) {
-            try {
-                const contact = await service.getContact(args.contactMid);
-                displayName = contact?.displayName ?? '';
-            }
-            catch {
-                // Leave empty — LINE resolves the name from the mid on the recipient side.
-            }
+            // Leave empty — LINE resolves the name from the mid on the recipient side.
         }
     }
     const result = await service.sendContact(args.chatId, args.contactMid, displayName);

package/dist/mcp/media.js

@@ -14,6 +14,7 @@
  * callers get an honest error naming the reason.
  */
 import { downloadLineMessageData, downloadLineObsMediaObject, } from '../line/client/obs-media-client.js';
+import { isSquareChatMid } from '../line/client/square-service/client.js';
 import { CONTENT_TYPE } from '../line/core/constants.js';
 import { decryptLineMediaBytes } from '../line/core/media-decrypt.js';
 /** LINE content types this server can download and decrypt via the OBS path. */
@@ -57,6 +58,51 @@ const MIME_BY_EXTENSION = {
     webp: 'image/webp',
     zip: 'application/zip',
 };
+const TRUSTED_PUBLIC_MEDIA_HOST_SUFFIXES = [
+    'line-scdn.net',
+    'line-apps.com',
+    'cdn.hinet.net',
+];
+export function resolvePublicMediaUrl(message, preview) {
+    const metadata = message?.contentMetadata ?? {};
+    if (metadata.PUBLIC !== 'true')
+        return null;
+    const raw = preview
+        ? metadata.PREVIEW_URL || metadata.DOWNLOAD_URL
+        : metadata.DOWNLOAD_URL || metadata.PREVIEW_URL;
+    if (typeof raw !== 'string' || !raw)
+        return null;
+    try {
+        const url = new URL(raw);
+        const hostname = url.hostname.toLowerCase();
+        if (url.protocol !== 'https:' ||
+            !TRUSTED_PUBLIC_MEDIA_HOST_SUFFIXES.some((suffix) => hostname === suffix || hostname.endsWith(`.${suffix}`))) {
+            return null;
+        }
+        return url;
+    }
+    catch {
+        return null;
+    }
+}
+async function downloadPublicMedia(url) {
+    const response = await fetch(url, { redirect: 'error' });
+    if (!response.ok) {
+        throw new Error(`Public LINE media download failed (${response.status})`);
+    }
+    const length = Number(response.headers.get('content-length') ?? 0);
+    if (Number.isFinite(length) && length > 25 * 1024 * 1024) {
+        throw new Error('Public LINE media exceeds 25 MB');
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length === 0 || bytes.length > 25 * 1024 * 1024) {
+        throw new Error('Public LINE media returned invalid bytes');
+    }
+    return {
+        bytes,
+        mimeType: response.headers.get('content-type')?.split(';')[0] || null,
+    };
+}
 /**
  * Resolve the short media-kind label for a LINE content type.
  *
@@ -125,10 +171,18 @@ export function resolveLineMediaDescriptor(message) {
     }
     const dataPayload = parseJson(message?.text, {});
     const mediaInfo = parseJson(contentMetadata.MEDIA_CONTENT_INFO, {});
+    const fileName = dataPayload.fileName ||
+        (typeof contentMetadata.FILE_NAME === 'string' &&
+            contentMetadata.FILE_NAME) ||
+        (typeof contentMetadata.FILE_NAME_ORIGINAL === 'string' &&
+            contentMetadata.FILE_NAME_ORIGINAL) ||
+        (typeof contentMetadata.name === 'string' && contentMetadata.name) ||
+        null;
+    const extension = mediaInfo.extension || (fileName ? fileName.split('.').pop() : null) || null;
     return {
-        fileName: dataPayload.fileName || null,
+        fileName,
         keyMaterial: dataPayload.keyMaterial || null,
-        mimeType: resolveMimeType(mediaInfo.extension || null, Number(message?.contentType || 0)),
+        mimeType: resolveMimeType(extension, Number(message?.contentType || 0)),
         oid: String(contentMetadata.OID),
         sid: String(contentMetadata.SID),
     };
@@ -165,6 +219,38 @@ class UnsupportedMediaTypeError extends LineMediaAccessError {
  * @returns Decrypted media bytes, resolved MIME type, filename, and content type.
  */
 export async function fetchLineMessageMedia(service, chatId, messageId, preview) {
+    if (isSquareChatMid(chatId)) {
+        const mainMessages = await service.client.getSquareChatMessages(chatId, 100);
+        let message = mainMessages.find((candidate) => candidate.id === messageId);
+        if (!message) {
+            for (const root of mainMessages.filter((candidate) => candidate.isThreadRoot && candidate.threadMid)) {
+                const replies = await service.client.getSquareChatMessages(chatId, 100, root.threadMid);
+                message = replies.find((candidate) => candidate.id === messageId);
+                if (message)
+                    break;
+            }
+        }
+        if (!message) {
+            throw new MissingDecryptMaterialError(`Square message ${messageId} not found in ${chatId}`);
+        }
+        const contentType = Number(message.contentType);
+        if (!DOWNLOADABLE_CONTENT_TYPES.has(contentType)) {
+            throw new UnsupportedMediaTypeError(contentType, messageId);
+        }
+        const downloaded = await downloadLineMessageData(service.client, {
+            messageId,
+            preview,
+            square: true,
+        });
+        return {
+            bytes: downloaded.bytes,
+            contentType,
+            fileName: message.contentMetadata?.FILE_NAME || null,
+            mimeType: downloaded.mimeType ||
+                DEFAULT_MIME_BY_CONTENT_TYPE[contentType] ||
+                'application/octet-stream',
+        };
+    }
     const messages = await service.getRecentMessages(chatId, 100);
     const message = messages.find((candidate) => candidate.id === messageId);
     if (!message) {
@@ -174,6 +260,19 @@ export async function fetchLineMessageMedia(service, chatId, messageId, preview)
     if (!DOWNLOADABLE_CONTENT_TYPES.has(contentType)) {
         throw new UnsupportedMediaTypeError(contentType, messageId);
     }
+    const publicMediaUrl = resolvePublicMediaUrl(message, preview);
+    if (publicMediaUrl) {
+        const downloaded = await downloadPublicMedia(publicMediaUrl);
+        const extension = publicMediaUrl.pathname.split('.').pop() ?? null;
+        return {
+            bytes: downloaded.bytes,
+            contentType,
+            fileName: null,
+            mimeType: downloaded.mimeType ||
+                resolveMimeType(extension, contentType) ||
+                'application/octet-stream',
+        };
+    }
     const descriptor = resolveLineMediaDescriptor(message);
     if (!descriptor) {
         // Older/non-E2EE Talk messages carry MEDIA_CONTENT_INFO but omit OID/SID.