@rikaidev/yomi 0.4.2 → 0.6.0

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

@@ -0,0 +1,453 @@
+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',
+    'FLEX_MESSAGE',
+    'CONTENTS',
+    'MARKUP_JSON',
+];
+function parseObject(value) {
+    if (typeof value !== 'string')
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function webUrl(value) {
+    if (typeof value !== 'string')
+        return null;
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:'
+            ? url.toString()
+            : null;
+    }
+    catch {
+        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 = [];
+    const images = [];
+    const actions = [];
+    const seen = new Set();
+    let visited = 0;
+    const addText = (value) => {
+        if (typeof value !== 'string')
+            return;
+        const clean = value.replace(/\s+/g, ' ').trim();
+        if (clean && !texts.includes(clean))
+            texts.push(clean);
+    };
+    const walk = (raw, depth = 0) => {
+        if (depth > 24 || visited >= 800)
+            return;
+        const value = parseObject(raw);
+        if (!value || typeof value !== 'object' || seen.has(value))
+            return;
+        seen.add(value);
+        visited += 1;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item, depth + 1);
+            return;
+        }
+        const node = value;
+        const type = typeof node.type === 'string' ? node.type.toLowerCase() : '';
+        if (type === 'text' || type === 'span')
+            addText(node.text);
+        if (type === 'image' || type === 'video') {
+            const image = webUrl(node.url) || webUrl(node.previewUrl);
+            if (image && !images.includes(image))
+                images.push(image);
+        }
+        const action = parseObject(node.action);
+        if (action && typeof action === 'object' && !Array.isArray(action)) {
+            const record = action;
+            const label = [record.label, record.displayText, record.text].find((item) => typeof item === 'string' && item.trim().length > 0) ?? '';
+            const url = webUrl(record.uri);
+            if (label || url)
+                actions.push({ label: label.trim(), url });
+        }
+        const ordered = [
+            'header',
+            'hero',
+            'body',
+            'footer',
+            'contents',
+            'altContent',
+        ];
+        for (const key of ordered)
+            if (key in node)
+                walk(node[key], depth + 1);
+        for (const [key, child] of Object.entries(node)) {
+            if (ordered.includes(key) ||
+                ['action', 'type', 'text', 'url', 'previewUrl'].includes(key))
+                continue;
+            if (child && typeof child === 'object')
+                walk(child, depth + 1);
+        }
+    };
+    walk(payload);
+    const machineLabels = new Set(['uri', 'url', 'link', 'open', 'action']);
+    const actionLabels = actions.map((item) => item.label).filter(Boolean);
+    const readableActionLabels = actionLabels.filter((label) => !machineLabels.has(label.toLowerCase()));
+    const readable = [
+        ...texts,
+        ...readableActionLabels.filter((label) => !texts.includes(label)),
+    ];
+    return {
+        summary: readable.join(' · ').slice(0, 700),
+        imageUrl: images[0] ?? null,
+        actionUrl: actions.find((item) => item.url)?.url ?? null,
+        actionLabels,
+    };
+}
+export function interpretFlexMessage(message) {
+    const metadata = message?.contentMetadata && typeof message.contentMetadata === 'object'
+        ? message.contentMetadata
+        : {};
+    for (const key of FLEX_PAYLOAD_KEYS) {
+        const parsed = parseObject(metadata[key]);
+        if (parsed)
+            return interpretFlexPayload(parsed);
+    }
+    const textPayload = parseObject(message?.text);
+    return textPayload
+        ? interpretFlexPayload(textPayload)
+        : {
+            summary: '',
+            imageUrl: null,
+            actionUrl: null,
+            actionLabels: [],
+        };
+}

package/dist/line/core/mention.js

@@ -10,7 +10,7 @@
  * - `M` is the mentioned user's MID; `S`/`E` are the start/end offsets as
  *   *strings*, not numbers.
  * - The range is half-open `[S, E)`, measured in UTF-16 code units — i.e.
- *   plain JS string indices (`"@鄭富源".length === 4` matched `S:"0", E:"4"`).
+ *   plain JavaScript string indices (a three-code-unit name plus `@` matched `S:"0", E:"4"`).
  * - Key order inside a mentionee object is not significant.
  * - MENTION rides in `contentMetadata`, which is never part of an E2EE
  *   ciphertext payload — it was observed in the clear on a real message.

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

@@ -0,0 +1,60 @@
+/**
+ * Convert raw/decrypted LINE payloads into safe user-facing preview text.
+ *
+ * E2EE media envelopes are transport data, not message text. They commonly
+ * contain keyMaterial, keys, chunks, ciphertext, or nonce fields. This
+ * boundary must be shared by every conversation/message output path so a raw
+ * message cannot bypass the decrypted-path sanitizer.
+ */
+const OPAQUE_FIELD = /(?:^|["'\s,{])(keymaterial|keys|chunks|ciphertext|nonce)\s*["']?\s*:/i;
+const OPAQUE_TOKEN = /\b(?:keymaterial|ciphertext|nonce)\b/i;
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function containsOpaqueField(value) {
+    if (typeof value === 'string') {
+        return (OPAQUE_FIELD.test(value) ||
+            (value.trim().startsWith('{') && OPAQUE_TOKEN.test(value)));
+    }
+    if (Array.isArray(value))
+        return value.some(containsOpaqueField);
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(([key, nested]) => /^(keymaterial|keys|chunks|ciphertext|nonce)$/i.test(key) ||
+        containsOpaqueField(nested));
+}
+/** Return only actual user text; opaque E2EE envelopes return an empty string. */
+export function sanitizeMessagePreview(value) {
+    if (containsOpaqueField(value))
+        return '';
+    if (typeof value !== 'string') {
+        if (!isRecord(value))
+            return '';
+        for (const key of ['text', 'message', 'body', 'content', 'caption']) {
+            const nested = sanitizeMessagePreview(value[key]);
+            if (nested)
+                return nested;
+        }
+        return '';
+    }
+    const text = value.trim();
+    if (!text)
+        return '';
+    if (!text.startsWith('{') && !text.startsWith('['))
+        return text;
+    try {
+        const parsed = JSON.parse(text);
+        if (!isRecord(parsed))
+            return '';
+        for (const key of ['text', 'message', 'body', 'content', 'caption']) {
+            const nested = sanitizeMessagePreview(parsed[key]);
+            if (nested)
+                return nested;
+        }
+        return '';
+    }
+    catch {
+        // A non-JSON message beginning with punctuation is still normal text.
+        return text;
+    }
+}

package/dist/line/core/message-query-service.js

@@ -137,25 +137,5 @@ export function createMessageQueryService(getClient, e2eeManager) {
             });
             return decryptLineMessages(e2eeManager, messages, chatId);
         },
-        /**
-         * Download the original LINE content bytes for one message.
-         *
-         * @param messageId - LINE message identifier
-         * @param requestId - Optional request identifier
-         * @returns Original message content bytes
-         */
-        async downloadMessageContent(messageId, requestId = `yomi-${Date.now()}`) {
-            return requireLineClient(getClient).downloadMessageContent(messageId, requestId);
-        },
-        /**
-         * Download the LINE preview bytes for one message.
-         *
-         * @param messageId - LINE message identifier
-         * @param requestId - Optional request identifier
-         * @returns Preview content bytes
-         */
-        async downloadMessageContentPreview(messageId, requestId = `yomi-${Date.now()}`) {
-            return requireLineClient(getClient).downloadMessageContentPreview(messageId, requestId);
-        },
     };
 }

package/dist/line/core/service.js

@@ -58,10 +58,10 @@ export class LineProtocolService extends EventEmitter {
     invalidateSession;
     tryRefreshToken;
     resumeSession;
-    resolveName;
     getContact;
     getGroup;
     listStickerPackages;
+    getAllMessageBoxes;
     searchStickerPackages;
     sendMessage;
     sendImage;
@@ -73,8 +73,6 @@ export class LineProtocolService extends EventEmitter {
     sendLocation;
     getRecentMessages;
     getPreviousMessages;
-    downloadMessageContent;
-    downloadMessageContentPreview;
     markChatRead;
     renameGroup;
     inviteToGroup;

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);
 }
 /**