@rikaidev/yomi 0.4.2 → 0.6.0

package/dist/cli/work-item.js

@@ -0,0 +1,24 @@
+import { InMemoryWorkItemStore, LineWorkItemAdapter, LocalReviewProvider, WorkItemProviderRegistry, WorkItemService, } from '../work-item/index.js';
+/**
+ * Read-only/create-draft bridge for the desktop and CLI callers. It never
+ * sends to a destination; callers must explicitly select a provider and
+ * approve the draft before delivery.
+ */
+export async function cliCreateWorkItemDraftJson(input, options = {}) {
+    const service = new WorkItemService(new InMemoryWorkItemStore());
+    return service.create(new LineWorkItemAdapter(), input, options);
+}
+/** Execute only local Work Item transitions; no external provider is registered. */
+export async function cliWorkItemOperationJson(operation, draft) {
+    const store = new InMemoryWorkItemStore();
+    const provider = new LocalReviewProvider();
+    const registry = new WorkItemProviderRegistry().register(provider);
+    const service = new WorkItemService(store, registry);
+    await store.save(draft);
+    if (operation === 'local-review') {
+        return service.deliverByProviderId(draft.id, 'local.review');
+    }
+    return service.transition(draft.id, {
+        type: operation === 'preview' ? 'preview' : 'approve',
+    });
+}

package/dist/insight/relationships.js

@@ -1,5 +1,5 @@
 /**
- * The relationship layer: who you talk to, how, and how often — the 對象/關係
+ * The relationship layer: who you talk to, how, and how often — the contact/relationship
  * axis of the analysis, built purely from interaction structure (no message
  * content). This is unsupervised context for the agent's final judgement, not a
  * judgement itself.

package/dist/line/auth/protocol/pwless-login-flow.js

@@ -65,6 +65,18 @@ export async function performPwlessLogin(service, phone, region, loggingInState,
             });
         }
         service.profile = await service.client.getProfile();
+        if (service.profile) {
+            if (service.profile.displayName) {
+                await service.credentialStore.set('displayName', service.profile.displayName);
+            }
+            if (service.profile.picturePath) {
+                await service.credentialStore.set('picturePath', service.profile.picturePath);
+                await service.credentialStore.set('pictureUrl', `https://obs.line-scdn.net/${service.profile.picturePath}`);
+            }
+            if (service.profile.statusMessage) {
+                await service.credentialStore.set('statusMessage', service.profile.statusMessage);
+            }
+        }
         // Display name only — do not print the mid alongside it.
         log?.info?.('profile.ok', {
             displayName: service.profile?.displayName ?? null,

package/dist/line/auth/pwless/index.js

@@ -49,7 +49,7 @@ export const PAAK_AUTH_CLIENT_CEILING_MS = PWLESS_POLL_TIMEOUT_MS * PAAK_AUTH_PO
  * This is an EXTERNAL FACT, not derived from any of our code or protocol
  * traffic. Source: LINE Help Center (zh-Hant),
  * https://help.line.me/line/IOSSecondary/?contentId=20018574&lang=zh-Hant
- * — on the primary device, tick the device signing in and tap 「用戶確認」
+ * — on the primary device, select the device signing in and confirm the user
  * within 3 minutes of the code being displayed.
  */
 export const LINE_PIN_CODE_LIFETIME_MS = 3 * 60 * 1000;

package/dist/line/client/auth-service/client.js

@@ -39,6 +39,9 @@ function unwrapAuthSuccess(method, result) {
     }
     return result.fields?.[0] ?? true;
 }
+function stringifyAuthValue(value) {
+    return (JSON.stringify(value, (_key, item) => typeof item === 'bigint' ? item.toString() : item) ?? String(value));
+}
 /**
  * Create the auth capability bound to one LINE client runtime.
  *
@@ -68,7 +71,7 @@ export function createAuthClient(runtime) {
             }
             if (result.fields?.[1] && typeof result.fields[1] === 'object') {
                 const exc = result.fields[1];
-                const msg = typeof exc[2] === 'string' ? exc[2] : JSON.stringify(exc);
+                const msg = typeof exc[2] === 'string' ? exc[2] : stringifyAuthValue(exc);
                 console.error(`[LINE] ${method} exception: ${msg}`);
             }
             return result;
@@ -83,10 +86,7 @@ export function createAuthClient(runtime) {
             // stderr-only logger — stdout is the MCP JSON-RPC channel and this runs
             // inside the stdio server (token refresh on resume/rotation).
             const lineLog = getLineClientLog(runtime);
-            lineLog.info('auth.refresh.call', {
-                auth: `${String(runtime.authToken || '').slice(0, 16)}...`,
-                refresh: `${String(refreshToken || '').slice(0, 12)}...`,
-            });
+            lineLog.info('auth.refresh.call');
             const result = await runtime.sendAuth('refresh', [[12, 1, [[11, 1, refreshToken]]]], LINE_APP_CONFIG.tokenRefreshPath);
             const resp = result.fields?.[0];
             if (resp?.[1]) {
@@ -95,7 +95,6 @@ export function createAuthClient(runtime) {
                 const durationUntilRefreshInSec = typeof resp[2] === 'bigint' ? Number(resp[2]) : resp[2] || 0;
                 const tokenIssueTimeEpochSec = typeof resp[3] === 'bigint' ? Number(resp[3]) : resp[3] || null;
                 lineLog.info('auth.refresh.success', {
-                    auth: `${String(resp[1]).slice(0, 16)}...`,
                     next_in_hours: Math.round(durationUntilRefreshInSec / 3600),
                 });
                 return {
@@ -104,8 +103,8 @@ export function createAuthClient(runtime) {
                     tokenIssueTimeEpochSec,
                 };
             }
-            console.error('[LINE] refresh() exception payload:', JSON.stringify(result, (_key, val) => typeof val === 'bigint' ? val.toString() : val));
-            throw new Error(`Token refresh failed: ${JSON.stringify(result, (_key, val) => (typeof val === 'bigint' ? val.toString() : val))}`);
+            lineLog.warn('auth.refresh.rejected');
+            throw new Error('Token refresh was rejected by LINE');
         },
         /**
          * Report a freshly rotated access token back to LINE's auth service.

package/dist/line/client/buddy-service/client.js

@@ -0,0 +1,73 @@
+export function createBuddyClient(runtime) {
+    return {
+        async getBuddyRichMenu(buddyMid) {
+            const detail = await runtime.sendBinary('/BUDDY3', 'getBuddyDetailWithPersonal', [
+                [11, 1, buddyMid],
+                [14, 2, [8, [0, 1, 2]]],
+            ]);
+            const buddy = detail.fields?.[0]?.[1];
+            const personal = detail.fields?.[0]?.[2];
+            const richMenuId = personal?.[1];
+            if (!richMenuId)
+                return null;
+            const chatBar = await runtime.sendBinary('/BUDDY3', 'getBuddyChatBarV2', [
+                [
+                    12,
+                    1,
+                    [
+                        [11, 1, buddyMid],
+                        [10, 2, buddy?.[21] || 0],
+                        [11, 3, richMenuId],
+                    ],
+                ],
+            ]);
+            const rich = (chatBar.fields?.[0]?.[1] || [])
+                .map((item) => item?.[1])
+                .find((item) => typeof item?.[2] === 'string');
+            if (!rich)
+                return null;
+            let body;
+            try {
+                body = JSON.parse(rich[2]);
+            }
+            catch {
+                return null;
+            }
+            const canvas = body?.canvas;
+            const scene = body?.scenes?.[canvas?.initialScene];
+            const image = Object.values(body?.images || {})[0];
+            if (!canvas || !scene || !image?.imageUrl)
+                return null;
+            const areas = (scene.listeners || []).flatMap((listener) => {
+                const [x, y, width, height] = listener?.params || [];
+                const action = body?.actions?.[listener?.action];
+                if (![x, y, width, height].every(Number.isFinite) || !action)
+                    return [];
+                return [
+                    {
+                        x,
+                        y,
+                        width,
+                        height,
+                        type: String(action.type || ''),
+                        uri: typeof action.params?.linkUri === 'string'
+                            ? action.params.linkUri
+                            : null,
+                        text: typeof action.params?.text === 'string'
+                            ? action.params.text
+                            : null,
+                    },
+                ];
+            });
+            return {
+                label: String(rich[1] || '選單'),
+                richMenuId: String(richMenuId),
+                selected: Boolean(rich[3]),
+                width: Number(canvas.width),
+                height: Number(canvas.height),
+                imageUrl: String(image.imageUrl),
+                areas,
+            };
+        },
+    };
+}

package/dist/line/client/index.js

@@ -20,11 +20,14 @@ import { createCliLogger } from '../../util/log.js';
 import { LINE_APP_CONFIG } from '../core/config.js';
 import { encodeCallMessage } from '../core/thrift/index.js';
 import { createAuthClient } from './auth-service/client.js';
+import { createBuddyClient } from './buddy-service/client.js';
 import { createE2EEClient } from './e2ee-service/client.js';
 import { parseOperation } from './parsers.js';
 import { createShopClient } from './shop-service/client.js';
+import { createSquareClient } from './square-service/client.js';
 import { createSyncClient } from './sync-service/client.js';
 import { createTalkCommandClient } from './talk-service/command-client.js';
+import { decodeBinaryResponseMessage, encodeBinaryCallMessage, postBinary, } from './talk-service/message-id-query.js';
 import { createTalkQueryClient } from './talk-service/query-client.js';
 import { sendRequest } from './transport.js';
 const TALK_EXCEPTION_CODE_NAMES = {
@@ -128,11 +131,17 @@ export class LineClient extends EventEmitter {
     openAuthSession;
     issueV3TokenForPrimary;
     restoreE2EEKeyBackup;
-    downloadMessageContent;
-    downloadMessageContentPreview;
     logoutZ;
     getOwnedStickerPackages;
+    getJoinedSquareChats;
+    getSquareChatMessages;
+    getSquareChatStatus;
+    getSquareChatLatestMessage;
+    markSquareChatRead;
+    sendSquareMessage;
+    getBuddyRichMenu;
     updateChatName;
+    updateContactNotificationDisabled;
     inviteIntoChat;
     deleteOtherFromChat;
     deleteSelfFromChat;
@@ -157,7 +166,7 @@ export class LineClient extends EventEmitter {
         this.seq = 1;
         this.logger = config.logger || createCliLogger('LINE');
         this.startupFlowLogger = config.startupFlowLogger || null;
-        Object.assign(this, createAuthClient(this), createTalkQueryClient(this), createTalkCommandClient(this), createSyncClient(this), createE2EEClient(this), createShopClient(this));
+        Object.assign(this, createAuthClient(this), createBuddyClient(this), createTalkQueryClient(this), createTalkCommandClient(this), createSyncClient(this), createE2EEClient(this), createShopClient(this), createSquareClient(this));
     }
     /**
      * Send a TCompact Thrift call to an arbitrary LINE service endpoint path.
@@ -201,6 +210,22 @@ export class LineClient extends EventEmitter {
     async sendTalk(method, args) {
         return this.sendCompact(LINE_APP_CONFIG.talkPath, method, args);
     }
+    async sendBinary(path, method, args) {
+        const body = encodeBinaryCallMessage(method, this.seq++, args);
+        const response = await postBinary(this.host, path, body, this.authToken);
+        if (response.nextToken) {
+            this.authToken = response.nextToken;
+            this.emit('tokenRotated', response.nextToken);
+        }
+        if (!response.body.length) {
+            throw new Error(`${method}(${path}) returned an empty response`);
+        }
+        const decoded = decodeBinaryResponseMessage(response.body);
+        if (decoded.fields?.[1]) {
+            throw new Error(`${method}(${path}) failed: ${decoded.fields[1]?.[2] || JSON.stringify(decoded.fields[1])}`);
+        }
+        return decoded;
+    }
     /**
      * Parse a raw Thrift operation struct into a domain object.
      *

package/dist/line/client/obs-media-client.js

@@ -9,6 +9,44 @@ const OBS_HOST = 'obs.line-apps.com';
 // (LINE_GW_HOST_DOMAIN). obs.line-apps.com returns 400 for the /oa/ upload
 // route; only the gateway accepts it, and only with an encrypted access token.
 const OBS_UPLOAD_HOST = 'gwz.line.naver.jp';
+/**
+ * Download media sent by a legacy/non-E2EE Talk client.
+ *
+ * These messages do not carry the OID/SID pair used by the newer E2EE OBS
+ * object format.  LINE's self-client protocol exposes them under the message
+ * object route instead:
+ *   GET https://obs.line-apps.com/r/talk/m/{messageId}[\/preview]
+ *
+ * This is deliberately not implemented as a TalkService call.  There is no
+ * `downloadMessageContent*` method on the current `/S4` service; sending such
+ * a Thrift call yields `Invalid method name`.
+ */
+export async function downloadLineMessageData(client, options) {
+    const messageId = String(options.messageId || '').trim();
+    if (!messageId) {
+        throw new Error('LINE legacy media download requires a message id');
+    }
+    const suffix = options.preview ? '/preview' : '';
+    const namespace = options.square ? 'g2' : 'talk';
+    const requestUrl = `https://${OBS_HOST}/r/${namespace}/m/${encodeURIComponent(messageId)}${suffix}`;
+    const response = await fetch(requestUrl, {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json, text/plain, */*',
+            'User-Agent': LINE_APP_CONFIG.userAgent,
+            'X-Line-Access': client.authToken,
+            'X-Line-Application': LINE_APP_CONFIG.lineApp,
+        },
+    });
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (!response.ok || bytes.length === 0) {
+        throw new Error(`LINE legacy media download failed: status=${response.status} bytes=${bytes.length}`);
+    }
+    return {
+        bytes,
+        mimeType: response.headers.get('content-type')?.split(';', 1)[0] || null,
+    };
+}
 /**
  * Build LINE talk metadata required for OBS media downloads.
  *

package/dist/line/client/parsers.js

@@ -26,6 +26,7 @@ export function parseMessage(msg) {
                 ? Number(msg[7])
                 : (msg[6] ?? msg[7]),
         text: msg[10] || null,
+        contentPreview: msg[17] || null,
         contentType: msg[15] || 0,
         contentMetadata: msg[18] || {},
         chunks: msg[20] || null,

package/dist/line/client/square-service/client.js

@@ -0,0 +1,298 @@
+/**
+ * Read-only LINE OpenChat (SquareService) capability.
+ *
+ * OpenChat is a separate service from TalkService: joined chats use `t...`
+ * MIDs and never appear in TalkService message boxes. Keep the protocol
+ * boundary explicit so callers cannot accidentally treat Square messages as
+ * ordinary group messages.
+ */
+import { LINE_APP_CONFIG } from '../../core/config.js';
+import { i32Field, i64Field, mapField, setField, stringField, structField, } from '../../core/thrift/index.js';
+function mapEntries(value) {
+    if (value instanceof Map)
+        return Array.from(value.entries());
+    if (value && typeof value === 'object')
+        return Object.entries(value);
+    return [];
+}
+/** LINE currently emits `m...` SquareChat MIDs; older schemas used `t...`. */
+export function isSquareChatMid(value) {
+    return value.startsWith('m') || value.startsWith('t');
+}
+function normalizeJoinedChat(chat, status, member) {
+    const id = String(chat?.[1] || '');
+    if (!isSquareChatMid(id))
+        return null;
+    const lastSquareMessage = status?.[3];
+    return {
+        id,
+        squareMid: chat?.[2] ? String(chat[2]) : null,
+        memberMid: member?.[1] ? String(member[1]) : null,
+        name: String(chat?.[4] || 'LINE 社群'),
+        pictureHash: chat?.[5] ? String(chat[5]) : null,
+        unreadCount: Number(status?.[5]?.[2] || 0),
+        lastMessage: lastSquareMessage?.[1] || null,
+        lastSenderName: status?.[4] ? String(status[4]) : null,
+        isMuted: member?.[5] === false,
+    };
+}
+function eventMessage(event) {
+    const payload = event?.[4];
+    const received = payload?.[1];
+    const sent = payload?.[2];
+    const mutated = payload?.[41];
+    const notification = payload?.[30];
+    const envelope = received || sent || mutated || notification;
+    const squareMessage = envelope?.[2];
+    const message = squareMessage?.[1];
+    if (!message)
+        return null;
+    const chatId = String(envelope?.[1] || message?.[2] || '');
+    const id = String(message?.[4] || '');
+    if (!chatId || !id)
+        return null;
+    const fromMid = String(message?.[1] || '');
+    return {
+        id,
+        chatId,
+        fromMid,
+        fromName: fromMid ? `成員 ${fromMid.slice(-4)}` : '匿名成員',
+        fromPictureUrl: null,
+        isSelf: Boolean(sent),
+        text: typeof message?.[10] === 'string' ? message[10] : '',
+        createdTime: Number(message?.[6] || message?.[5] || event?.[2] || 0),
+        contentType: Number(message?.[15] || 0),
+        contentMetadata: message?.[18] && typeof message[18] === 'object' ? message[18] : {},
+        threadMid: squareMessage?.[6]?.[1]
+            ? String(squareMessage[6][1])
+            : envelope?.[7]
+                ? String(envelope[7])
+                : null,
+        isThreadRoot: Boolean(squareMessage?.[6]?.[2]),
+    };
+}
+export function createSquareClient(runtime) {
+    const memberProfiles = new Map();
+    async function resolveMember(squareMemberMid) {
+        const cached = memberProfiles.get(squareMemberMid);
+        if (cached)
+            return cached;
+        try {
+            const result = await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'getSquareMember', [structField(1, [stringField(1, squareMemberMid)])]);
+            const member = result.fields?.[0]?.[1];
+            const displayName = String(member?.[3] || '').trim();
+            const pictureHash = String(member?.[4] || '').trim();
+            if (displayName) {
+                const profile = {
+                    displayName,
+                    pictureUrl: pictureHash
+                        ? `https://obs.line-scdn.net/${pictureHash.replace(/^\/+/, '')}`
+                        : null,
+                };
+                memberProfiles.set(squareMemberMid, profile);
+                return profile;
+            }
+        }
+        catch (error) {
+            if (process.env.YOMI_DEBUG_SQUARE_MEMBER === '1') {
+                console.error('[square] getSquareMember failed', error instanceof Error ? error.message : String(error));
+            }
+        }
+        return null;
+    }
+    async function resolveMembers(squareMemberMids) {
+        const unresolved = squareMemberMids.filter((mid) => !memberProfiles.has(mid));
+        if (unresolved.length === 0)
+            return;
+        try {
+            const result = await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'getSquareMembers', [structField(1, [setField(2, 11, unresolved)])]);
+            const raw = result.fields?.[0]?.[1];
+            const candidates = raw && typeof raw?.[1] === 'string'
+                ? [raw]
+                : mapEntries(raw).map(([, member]) => member);
+            for (const member of candidates) {
+                const mid = String(member?.[1] || '');
+                const displayName = String(member?.[3] || '').trim();
+                const pictureHash = String(member?.[4] || '').trim();
+                if (!mid || !displayName)
+                    continue;
+                memberProfiles.set(mid, {
+                    displayName,
+                    pictureUrl: pictureHash
+                        ? `https://obs.line-scdn.net/${pictureHash.replace(/^\/+/, '')}`
+                        : null,
+                });
+            }
+        }
+        catch (error) {
+            if (process.env.YOMI_DEBUG_SQUARE_MEMBER === '1') {
+                console.error('[square] getSquareMembers failed', error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    return {
+        async getJoinedSquareChats(limit = 100) {
+            const chats = [];
+            let continuationToken;
+            const seenTokens = [];
+            try {
+                for (;;) {
+                    const request = [i32Field(3, Math.max(1, Math.min(limit, 100)))];
+                    if (continuationToken)
+                        request.unshift(stringField(2, continuationToken));
+                    const result = await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'getJoinedSquareChats', [structField(1, request)]);
+                    const response = result.fields?.[0];
+                    const statuses = mapEntries(response?.[3]);
+                    const members = mapEntries(response?.[2]);
+                    for (const raw of Array.isArray(response?.[1]) ? response[1] : []) {
+                        const id = String(raw?.[1] || '');
+                        const chat = normalizeJoinedChat(raw, statuses.find(([key]) => key === id)?.[1], members.find(([key]) => key === id)?.[1]);
+                        if (chat)
+                            chats.push(chat);
+                    }
+                    const next = response?.[4] ? String(response[4]) : '';
+                    if (!next || seenTokens.includes(next) || chats.length >= limit)
+                        break;
+                    seenTokens.push(next);
+                    continuationToken = next;
+                }
+            }
+            catch (error) {
+                // LINE's Desktop identity currently answers getJoinedSquareChats with
+                // `501 NO XLT`. A bootstrap fetchMyEvents(subscriptionId=0) returns
+                // the authoritative CREATE_SQUARE_CHAT_MEMBER snapshots instead.
+                chats.length = 0;
+                let eventContinuation;
+                const seenEventTokens = [];
+                for (;;) {
+                    const request = [i64Field(1, 0), i32Field(3, 100)];
+                    if (eventContinuation)
+                        request.push(stringField(4, eventContinuation));
+                    const result = await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'fetchMyEvents', [structField(1, request)]);
+                    const response = result.fields?.[0];
+                    for (const event of Array.isArray(response?.[2]) ? response[2] : []) {
+                        const createdMembership = event?.[4]?.[17];
+                        const chat = normalizeJoinedChat(createdMembership?.[1], createdMembership?.[2], createdMembership?.[3]);
+                        if (chat)
+                            chats.push(chat);
+                    }
+                    const next = response?.[4] ? String(response[4]) : '';
+                    if (!next || seenEventTokens.includes(next) || chats.length >= limit)
+                        break;
+                    seenEventTokens.push(next);
+                    eventContinuation = next;
+                }
+                if (chats.length === 0)
+                    throw error;
+            }
+            return chats
+                .filter((chat, index) => chats.findIndex((item) => item.id === chat.id) === index)
+                .slice(0, limit);
+        },
+        async getSquareChatMessages(chatId, limit = 40, threadMid) {
+            if (!isSquareChatMid(chatId))
+                throw new Error('Invalid OpenChat MID');
+            const result = await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'fetchSquareChatEvents', [
+                structField(1, [
+                    i64Field(1, 0),
+                    stringField(2, chatId),
+                    i32Field(4, Math.max(1, Math.min(limit, 100))),
+                    i32Field(5, 1),
+                    i32Field(6, 1),
+                    i32Field(8, 1),
+                    ...(threadMid ? [stringField(9, threadMid)] : []),
+                ]),
+            ]);
+            const events = result.fields?.[0]?.[2];
+            const messages = [];
+            for (const event of Array.isArray(events) ? events : []) {
+                const message = eventMessage(event);
+                if (!message || message.chatId !== chatId)
+                    continue;
+                const existingIndex = messages.findIndex((item) => item.id === message.id);
+                if (existingIndex >= 0)
+                    messages[existingIndex] = message;
+                else
+                    messages.push(message);
+            }
+            const senderMids = [
+                ...new Set(messages.map((message) => message.fromMid).filter(Boolean)),
+            ];
+            await resolveMembers(senderMids);
+            await Promise.all(senderMids.map(async (mid) => {
+                const profile = await resolveMember(mid);
+                if (!profile)
+                    return;
+                for (const message of messages) {
+                    if (message.fromMid !== mid)
+                        continue;
+                    message.fromName = profile.displayName;
+                    message.fromPictureUrl = profile.pictureUrl;
+                }
+            }));
+            return messages
+                .sort((a, b) => a.createdTime - b.createdTime)
+                .slice(-limit);
+        },
+        async getSquareChatStatus(chatId) {
+            if (!isSquareChatMid(chatId))
+                throw new Error('Invalid OpenChat MID');
+            const result = await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'getSquareChatStatus', [structField(1, [stringField(2, chatId)])]);
+            return result.fields?.[0]?.[1] || null;
+        },
+        async getSquareChatLatestMessage(chatId) {
+            if (!isSquareChatMid(chatId))
+                throw new Error('Invalid OpenChat MID');
+            const result = await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'getSquareChatStatus', [structField(1, [stringField(2, chatId)])]);
+            const status = result.fields?.[0]?.[1];
+            const raw = status?.[3]?.[1];
+            if (!raw?.[4])
+                return null;
+            const fromMid = String(raw?.[1] || '');
+            const profile = fromMid ? await resolveMember(fromMid) : null;
+            return {
+                id: String(raw[4]),
+                chatId,
+                fromMid,
+                fromName: profile?.displayName || String(status?.[4] || '') || '匿名成員',
+                fromPictureUrl: profile?.pictureUrl || null,
+                isSelf: false,
+                text: typeof raw?.[10] === 'string' ? raw[10] : '',
+                createdTime: Number(raw?.[6] || raw?.[5] || 0),
+                contentType: Number(raw?.[15] || 0),
+                contentMetadata: raw?.[18] && typeof raw[18] === 'object' ? raw[18] : {},
+                threadMid: null,
+                isThreadRoot: false,
+            };
+        },
+        async markSquareChatRead(chatId, messageId) {
+            if (!isSquareChatMid(chatId))
+                throw new Error('Invalid OpenChat MID');
+            if (!messageId)
+                throw new Error('OpenChat message id required');
+            await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'markAsRead', [
+                structField(1, [stringField(2, chatId), stringField(4, messageId)]),
+            ]);
+        },
+        async sendSquareMessage(chatId, text, contentMetadata = {}) {
+            if (!isSquareChatMid(chatId))
+                throw new Error('Invalid OpenChat MID');
+            const messageFields = [
+                stringField(2, chatId),
+                stringField(10, text),
+                i32Field(15, 0),
+            ];
+            if (Object.keys(contentMetadata).length > 0) {
+                messageFields.push(mapField(18, 11, 11, contentMetadata));
+            }
+            const result = await runtime.sendCompact(LINE_APP_CONFIG.squarePath, 'sendMessage', [
+                structField(1, [
+                    i32Field(1, runtime.seq++),
+                    stringField(2, chatId),
+                    structField(3, [structField(1, messageFields), i64Field(4, 4)]),
+                ]),
+            ]);
+            return result.fields?.[0]?.[1] || null;
+        },
+    };
+}

package/dist/line/client/sticker-meta.js

@@ -8,6 +8,30 @@
  * package the caller wants to expand into sendable sticker ids.
  */
 const CDN = 'https://stickershop.line-scdn.net/stickershop/v1/product';
+// Metadata is public and immutable for the lifetime of a picker session. Keep
+// one in-flight/result promise per package so opening the picker or changing
+// locale does not refetch the same package repeatedly.
+const packageMetaCache = new Map();
+/** Pick the title users expect for the app's current language. */
+export function localizedStickerTitle(titles, language = 'en', fallback = '') {
+    const values = titles ?? {};
+    const normalized = language.replace('_', '-').toLowerCase();
+    const preferred = normalized.startsWith('zh')
+        ? ['zh-Hant', 'zh_TW', 'zh-TW', 'zh']
+        : normalized.startsWith('ja')
+            ? ['ja']
+            : ['en'];
+    for (const key of preferred) {
+        const value = values[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    const english = values.en;
+    if (typeof english === 'string' && english.trim())
+        return english.trim();
+    const first = Object.values(values).find((value) => typeof value === 'string' && value.trim());
+    return first?.trim() || fallback;
+}
 /**
  * Fetch one sticker package's public metadata (title + individual sticker ids).
  *
@@ -31,6 +55,14 @@ export async function fetchStickerPackageMeta(packageId) {
             .filter((id) => id !== null),
     };
 }
+export function fetchStickerPackageMetaCached(packageId) {
+    const cached = packageMetaCache.get(packageId);
+    if (cached)
+        return cached;
+    const request = fetchStickerPackageMeta(packageId);
+    packageMetaCache.set(packageId, request);
+    return request;
+}
 /**
  * Fetch one sticker's PNG preview image from the public sticker CDN.
  *