@rikaidev/yomi 0.2.6

package/dist/line/core/auth-session-runtime.js

@@ -0,0 +1,231 @@
+/**
+ * LINE auth/session restore and token refresh runtime.
+ */
+import { createCliLogger } from '../../util/log.js';
+import { recoverBootstrapKeys } from './e2ee/recovery/bootstrap-keys.js';
+import { STATE } from './service.js';
+const TERMINAL_ERROR_REGEX = /LOGGED_OUT|DIVESTED/i;
+const AUTH_ERROR_REGEX = /expired|unauthorized|authentication|invalid.*token/i;
+/**
+ * Resolve the active LINE logger for one runtime.
+ *
+ * @param service - LineProtocolService instance
+ * @returns Scope-bound CLI logger
+ */
+function getLineLog(service) {
+    if (service?.startupFlowLogger) {
+        return service.startupFlowLogger;
+    }
+    if (service?.logger?.info) {
+        return service.logger;
+    }
+    return createCliLogger('LINE');
+}
+/**
+ * Restore persisted E2EE self keys or recover them from bootstrap material.
+ *
+ * @param service - LineProtocolService instance.
+ * @param lineLog - Logger instance.
+ */
+async function restoreE2EEState(service, lineLog) {
+    const savedE2EEKeys = await service.credentialStore.get('line_e2ee_keys');
+    if (!savedE2EEKeys) {
+        await restoreBootstrapKeys(service, lineLog);
+        return;
+    }
+    try {
+        const parsedKeys = JSON.parse(savedE2EEKeys);
+        if (!Array.isArray(parsedKeys) || parsedKeys.length === 0) {
+            return;
+        }
+        service.e2eeManager.importKeys(parsedKeys);
+        const savedMid = await service.credentialStore.get('line_mid');
+        if (savedMid) {
+            service.e2eeManager.bindSelfKeysToMid(savedMid);
+        }
+        service.e2eeWarning = false;
+        service.emit('e2eeWarning', { active: false, reason: null });
+        lineLog.info('e2ee.restore.complete', { key_count: parsedKeys.length });
+    }
+    catch (error) {
+        lineLog.warn('e2ee.restore.failed', { error: error?.message });
+    }
+}
+/**
+ * Attempt E2EE restore from bootstrap material.
+ *
+ * @param service - LineProtocolService instance.
+ * @param lineLog - Logger instance.
+ */
+async function restoreBootstrapKeys(service, lineLog) {
+    const bootstrapKeys = await recoverBootstrapKeys(service);
+    if (bootstrapKeys?.length) {
+        service.e2eeWarning = false;
+        service.emit('e2eeWarning', {
+            active: false,
+            reason: null,
+            recoveredFromBootstrap: true,
+        });
+        lineLog.info('e2ee.restore.bootstrap_complete', {
+            key_count: bootstrapKeys.length,
+        });
+        return;
+    }
+    service.e2eeWarning = true;
+    service.emit('e2eeWarning', { active: true, reason: 'missing_keys' });
+    lineLog.warn('e2ee.restore.missing_keys', {
+        action: 'skip_undecrypted_messages_until_relogin',
+    });
+}
+/**
+ * Validate the restored session profile and decide next auth behavior.
+ *
+ * @param service - LineProtocolService instance.
+ * @param lineLog - Logger instance.
+ * @returns True when the session is considered restored.
+ */
+async function validateRestoredSession(service, lineLog) {
+    try {
+        const profile = await service.client.getProfile();
+        if (profile) {
+            service.profile = profile;
+            lineLog.info('session.restore.validated', {
+                profile: profile.displayName || profile.mid,
+            });
+        }
+        service.loginRequired = false;
+        service.loginReason = null;
+        service.setState(STATE.CONNECTED);
+        return true;
+    }
+    catch (validationErr) {
+        return handleSessionValidationError(service, lineLog, validationErr);
+    }
+}
+/**
+ * Handle auth/network errors encountered during restore validation.
+ *
+ * @param service - LineProtocolService instance.
+ * @param lineLog - Logger instance.
+ * @param validationErr - Validation error.
+ * @returns True when the session remains usable.
+ */
+async function handleSessionValidationError(service, lineLog, validationErr) {
+    const msg = validationErr?.message || '';
+    lineLog.warn('session.restore.validation_failed', { error: msg });
+    if (TERMINAL_ERROR_REGEX.test(msg)) {
+        // Never destroy credentials on a transient/error-path signal — a
+        // regex misfire or one bad response would otherwise cost the operator
+        // a phone-PIN re-login for nothing. The stale token stays on disk;
+        // a later successful login overwrites it via persistLoginCredentials.
+        // clearAuth() remains reserved for the explicit, user-initiated
+        // invalidateSession() path (see auth-session-service.ts).
+        lineLog.warn('session.restore.revoked', {
+            action: 'require_relogin_without_clearing_credentials',
+        });
+        service.loginRequired = true;
+        service.loginReason = 'revoked';
+        service.setState(STATE.DISCONNECTED);
+        service.emit('line:loginRequired');
+        return false;
+    }
+    if (AUTH_ERROR_REGEX.test(msg)) {
+        lineLog.info('session.restore.refresh_attempt');
+        const refreshed = await tryRefreshToken(service);
+        if (refreshed) {
+            service.loginRequired = false;
+            service.loginReason = null;
+            service.setState(STATE.CONNECTED);
+            return true;
+        }
+        // AUTH_ERROR_REGEX matched (expired/unauthorized/invalid token) and the
+        // silent refresh could not save it. Nothing revoked this device — the
+        // token just aged out, so don't tell the user someone logged in elsewhere.
+        service.loginRequired = true;
+        service.loginReason = 'expired';
+        service.setState(STATE.DISCONNECTED);
+        service.emit('line:loginRequired');
+        return false;
+    }
+    lineLog.warn('session.restore.trusted_optimistically');
+    service.loginRequired = false;
+    service.loginReason = null;
+    service.setState(STATE.CONNECTED);
+    return true;
+}
+/**
+ * Attempt to refresh the LINE auth token using the stored refresh token.
+ * Updates credentials in the credential store on success.
+ *
+ * @param service - LineProtocolService instance
+ * @returns True if the token was refreshed successfully, false otherwise.
+ */
+export async function tryRefreshToken(service) {
+    const lineLog = getLineLog(service);
+    try {
+        const refreshToken = service.sessionState.refreshToken ||
+            (await service.credentialStore.get('line_refresh_token'));
+        if (!refreshToken || !service.client) {
+            lineLog.info('auth.refresh.skip', {
+                reason: 'missing_refresh_token_or_client',
+            });
+            return false;
+        }
+        lineLog.info('auth.refresh.start');
+        const result = await service.client.refreshAuthToken(refreshToken);
+        await service.sessionState.applyRefreshResult(result);
+        try {
+            await service.client.reportRefreshedAccessToken?.(result.authToken);
+        }
+        catch (reportErr) {
+            lineLog.warn('auth.refresh.report_failed', { error: reportErr?.message });
+        }
+        lineLog.info('auth.refresh.complete', {
+            next_refresh_hours: Math.round((result.durationUntilRefreshInSec || 0) / 3600),
+        });
+        service.emit('tokenRotated', result.authToken);
+        return true;
+    }
+    catch (err) {
+        lineLog.error('auth.refresh.failed', { error: err?.message });
+        return false;
+    }
+}
+/**
+ * Restore a LINE session from saved credentials.
+ * Validates the token with getProfile(), falls back to token refresh on auth error,
+ * and emits 'line:loginRequired' if both fail.
+ *
+ * @param service - LineProtocolService instance
+ * @returns True if session was restored successfully, false if re-login is needed.
+ */
+export async function resumeSession(service) {
+    const lineLog = getLineLog(service);
+    try {
+        await service.sessionState.loadFromStore();
+        service.recentFetchState = await service.sessionState.loadRecentFetchState();
+        const token = service.sessionState.authToken;
+        if (!token) {
+            lineLog.info('session.restore.skip', { reason: 'no_saved_auth_token' });
+            return false;
+        }
+        lineLog.info('session.restore.start');
+        const { LineClient } = await import('../client/index.js');
+        service.client = new LineClient(token, {
+            logger: service.logger,
+            startupFlowLogger: service.startupFlowLogger,
+        });
+        // `service.client` is its own EventEmitter (see sync-service/client.ts's
+        // `runtime.emit('error', ...)` in the poll loop) — a zero-listener 'error'
+        // emit there throws uncaught and kills the process just like on `service`
+        // itself. Attach here, at construction, for the client's lifetime.
+        service.client.on('error', (error) => lineLog.warn('client.error', { error: error?.message ?? String(error) }));
+        service.sessionState.bindClient(service.client);
+        await restoreE2EEState(service, lineLog);
+        return validateRestoredSession(service, lineLog);
+    }
+    catch (outerErr) {
+        lineLog.error('session.restore.failed', { error: outerErr?.message });
+        return false;
+    }
+}

package/dist/line/core/auth-session-service.js

@@ -0,0 +1,85 @@
+/**
+ * LINE core auth/session capability.
+ */
+import { performPwlessLogin } from '../auth/protocol/index.js';
+import { performLogout } from './auth-session-logout.js';
+import { resumeSession as resumeSessionImpl, tryRefreshToken as tryRefreshTokenImpl, } from './auth-session-runtime.js';
+/**
+ * Create the auth/session capability bound to one LINE protocol service.
+ *
+ * @param service - Mutable LINE protocol service runtime.
+ * @param states - Service state constants.
+ * @returns Auth/session methods.
+ */
+export function createAuthSessionService(service, states) {
+    return {
+        /**
+         * Start the passwordless login process.
+         *
+         * @param phone - E.164 phone number.
+         * @param region - Region code.
+         * @returns Promise resolving to the login result.
+         */
+        async startPwlessLogin(phone, region) {
+            return performPwlessLogin(service, phone, region, states.LOGGING_IN, states.CONNECTED, states.ERROR);
+        },
+        /**
+         * Log out from LINE, clearing the local session regardless of remote result.
+         *
+         * @returns Promise resolving when logout completes.
+         */
+        async logout() {
+            return performLogout(service, states.DISCONNECTED);
+        },
+        /**
+         * Mark the active session as invalid after LINE rejects a previously saved token.
+         *
+         * @param reason - Operator/debug reason for invalidation.
+         */
+        async invalidateSession(reason = 'line_auth_invalidated') {
+            try {
+                service.client?.stopPolling?.();
+            }
+            catch {
+                // Polling may already be stopped.
+            }
+            const savedPhone = await service.credentialStore?.get?.('line_phone');
+            const savedRegion = await service.credentialStore?.get?.('line_region');
+            await service.sessionState.clearAuth();
+            if (savedPhone) {
+                await service.credentialStore?.set?.('line_phone', savedPhone);
+            }
+            if (savedRegion) {
+                await service.credentialStore?.set?.('line_region', savedRegion);
+            }
+            service.client = null;
+            service.profile = null;
+            service.e2eeWarning = false;
+            service.loginRequired = true;
+            // Only reached when LINE rejects a token it previously accepted, which
+            // is a revocation regardless of the operator-supplied debug reason.
+            service.loginReason = 'revoked';
+            service.nameCache.clear();
+            service.chatCache.clear();
+            service.setState(states.DISCONNECTED);
+            service.emit('line:loginRequired', { reason });
+            service.emit('error', new Error(reason));
+        },
+        /**
+         * Attempt token refresh via stored refresh token.
+         *
+         * @returns True when refresh succeeded.
+         */
+        async tryRefreshToken() {
+            return tryRefreshTokenImpl(service);
+        },
+        /**
+         * Restore a previously persisted LINE session.
+         *
+         * @returns True when the session was restored.
+         */
+        async resumeSession() {
+            return resumeSessionImpl(service);
+        },
+    };
+}

package/dist/line/core/chat-runtime-service.js

@@ -0,0 +1,343 @@
+/**
+ * LINE core chat/runtime capability — Yomi read-only + explicit-send subset.
+ *
+ * Yomi is primarily a pure query server: it exposes message read/download
+ * methods, plus one explicit, always-E2EE `sendMessage` write path used only
+ * by the `send_message` MCP tool. Capabilities this module intentionally
+ * does NOT carry over are: startPolling (continuous read-state mutation),
+ * scanChats / fetchRecentMessages (bulk backfill scanning),
+ * recoverE2EEContext, and createBackfillAdapter (pipeline-facing, depends
+ * on a backfill-adapter module that was not extracted). See
+ * yomi/README.md for the full extraction rationale.
+ */
+import { createMessageCommandService } from './message-command-service.js';
+import { createMessageQueryService } from './message-query-service.js';
+/**
+ * Create the chat/runtime capability bound to one LINE protocol service.
+ *
+ * @param service - Mutable LINE protocol service runtime.
+ * @returns Chat/runtime methods.
+ */
+export function createChatRuntimeService(service) {
+    return {
+        /**
+         * Send one plain-text LINE message, always E2EE-encrypted through the
+         * explicit message-command boundary. There is no plaintext-send path:
+         * the caller-facing `send_message` tool only ever reaches this method,
+         * and this method only ever asks for `{ e2ee: true }`. If the E2EE key
+         * material cannot be resolved (peer negotiation or group key fetch
+         * fails), the underlying encrypt call throws and no request reaches
+         * LINE — never a silent plaintext fallback.
+         *
+         * @param to - Recipient chat MID (1:1 `u...` or group/room `c.../r...`).
+         * @param text - Plain-text message body.
+         * @param contentMetadata - Optional extra contentMetadata to merge in
+         * alongside the E2EE markers — e.g. an outbound `MENTION` payload built
+         * via `../mention.ts`. Never part of the encrypted chunks; see the
+         * JSDoc on message-command-service.ts's `sendMessage` E2EE branch.
+         * @returns LINE sendMessage result (includes the sent message id).
+         */
+        async sendMessage(to, text, contentMetadata, reply) {
+            return createMessageCommandService(() => service.client, service.e2eeManager).sendMessage(to, {
+                e2ee: true,
+                text,
+                contentMetadata,
+                relatedMessageId: reply?.relatedMessageId ?? null,
+                messageRelationType: reply?.messageRelationType ?? null,
+                relatedMessageServiceCode: reply?.relatedMessageServiceCode ?? null,
+            });
+        },
+        /**
+         * Send one 1:1 E2EE image, always through the explicit
+         * upload-then-send message-command boundary. There is no plaintext or
+         * unencrypted-upload path: if the E2EE key material cannot be
+         * resolved, or the OBS upload is rejected, the underlying call throws
+         * and no message reaches LINE.
+         *
+         * @param to - Recipient chat MID (1:1 `u...`).
+         * @param imageBytes - Raw (plaintext) image bytes to send.
+         * @param fileName - Original filename, used to derive the extension.
+         * @returns `{ sent, messageId, oid }` describing the delivered image.
+         */
+        async sendImage(to, imageBytes, fileName) {
+            return createMessageCommandService(() => service.client, service.e2eeManager).sendImage(to, imageBytes, fileName);
+        },
+        /**
+         * Send one E2EE file attachment through the shared media-send pipeline.
+         *
+         * @param to - Recipient chat MID.
+         * @param fileBytes - Raw (plaintext) file bytes to send.
+         * @param fileName - Original filename (sealed E2EE for the recipient).
+         * @returns `{ sent, messageId, oid }` describing the delivered file.
+         */
+        async sendFile(to, fileBytes, fileName) {
+            return createMessageCommandService(() => service.client, service.e2eeManager).sendFile(to, fileBytes, fileName);
+        },
+        /**
+         * Send one E2EE audio message through the shared media-send pipeline.
+         *
+         * @param to - Recipient chat MID.
+         * @param audioBytes - Raw (plaintext) audio bytes.
+         * @param fileName - Original filename (for the OBS upload name).
+         * @param durationMs - Audio duration in ms, when known.
+         * @returns `{ sent, messageId, oid }` describing the delivered audio.
+         */
+        async sendAudio(to, audioBytes, fileName, durationMs) {
+            return createMessageCommandService(() => service.client, service.e2eeManager).sendAudio(to, audioBytes, fileName, durationMs);
+        },
+        /**
+         * Send one E2EE video message through the shared media-send pipeline.
+         *
+         * @param to - Recipient chat MID.
+         * @param videoBytes - Raw (plaintext) video bytes.
+         * @param fileName - Original filename (for the OBS upload name).
+         * @param durationMs - Video duration in ms, when known.
+         * @returns `{ sent, messageId, oid }` describing the delivered video.
+         */
+        async sendVideo(to, videoBytes, fileName, durationMs) {
+            return createMessageCommandService(() => service.client, service.e2eeManager).sendVideo(to, videoBytes, fileName, durationMs);
+        },
+        /**
+         * Share a LINE contact card (contentType CONTACT) — not media.
+         *
+         * @param to - Recipient chat MID.
+         * @param contactMid - MID of the person whose card is shared.
+         * @param displayName - Display name shown on the card.
+         * @returns `{ sent, messageId }` describing the delivered card.
+         */
+        async sendContact(to, contactMid, displayName) {
+            return createMessageCommandService(() => service.client, service.e2eeManager).sendContact(to, contactMid, displayName);
+        },
+        /**
+         * Send a LINE sticker (contentType STICKER) — not media.
+         *
+         * @param to - Recipient chat MID.
+         * @param stickerId - Sticker id (STKID).
+         * @param packageId - Sticker package id (STKPKGID).
+         * @param version - Sticker version (STKVER).
+         * @returns `{ sent, messageId }` describing the delivered sticker.
+         */
+        async sendSticker(to, stickerId, packageId, version) {
+            return createMessageCommandService(() => service.client, service.e2eeManager).sendSticker(to, stickerId, packageId, version);
+        },
+        /**
+         * Send a location message (contentType LOCATION) — not media, not E2EE.
+         *
+         * @param to - Recipient chat MID.
+         * @param latitude - Latitude.
+         * @param longitude - Longitude.
+         * @param title - Optional place name.
+         * @param address - Optional address.
+         * @returns `{ sent, messageId }` describing the delivered location.
+         */
+        async sendLocation(to, latitude, longitude, title, address) {
+            return createMessageCommandService(() => service.client, service.e2eeManager).sendLocation(to, latitude, longitude, title, address);
+        },
+        /**
+         * Fetch recent LINE messages through the explicit message-query boundary.
+         *
+         * @param chatId - LINE chat MID.
+         * @param count - Maximum number of messages.
+         * @returns Recent LINE messages.
+         */
+        async getRecentMessages(chatId, count = 50) {
+            return createMessageQueryService(() => service.client, service.e2eeManager).getRecentMessages(chatId, count);
+        },
+        /**
+         * Fetch one page of LINE messages older than a cursor.
+         *
+         * @param chatId - LINE chat MID.
+         * @param count - Maximum number of messages.
+         * @param before - Cursor identifying the oldest already-seen message.
+         * @returns Previous LINE messages, older than the cursor.
+         */
+        async getPreviousMessages(chatId, count = 50, before = {}) {
+            return createMessageQueryService(() => service.client, service.e2eeManager).getPreviousMessages(chatId, count, before);
+        },
+        /**
+         * 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) {
+            return createMessageQueryService(() => service.client, service.e2eeManager).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) {
+            return createMessageQueryService(() => service.client, service.e2eeManager).downloadMessageContentPreview(messageId, requestId);
+        },
+        /**
+         * Mark a LINE conversation read up to a message via the explicit
+         * sendChatChecked boundary. When messageId is omitted, resolves the most
+         * recent message id in the chat. NEVER called by background capture/sync —
+         * only by the send_message/send_image auto-read and the explicit mark_read
+         * tool. Honest no-op (marked:false) when there is no message to mark.
+         *
+         * @param chatId - LINE chat MID.
+         * @param messageId - Optional message id to mark read up to.
+         * @returns Result describing whether a read receipt was sent.
+         */
+        async markChatRead(chatId, messageId) {
+            let lastMessageId = messageId ?? null;
+            if (!lastMessageId) {
+                const recent = await service.getRecentMessages(chatId, 1);
+                lastMessageId = recent?.[0]?.id ? String(recent[0].id) : null;
+            }
+            if (!lastMessageId) {
+                return { marked: false, reason: 'no message to mark read' };
+            }
+            await service.client.sendChatChecked(chatId, lastMessageId, 0);
+            return { marked: true, chatId, lastMessageId };
+        },
+        /**
+         * Rename a group/chat (TalkService updateChat). Side effect visible to all
+         * members.
+         *
+         * @param chatId - Group/chat MID.
+         * @param name - New name.
+         * @returns `{ renamed, chatId, name }`.
+         */
+        async renameGroup(chatId, name) {
+            await service.client.updateChatName(chatId, name);
+            return { renamed: true, chatId, name };
+        },
+        /**
+         * Invite members into a group/chat (TalkService inviteIntoChat).
+         *
+         * @param chatId - Group/chat MID.
+         * @param mids - Member MIDs to invite.
+         * @returns `{ invited, chatId, mids }`.
+         */
+        async inviteToGroup(chatId, mids) {
+            await service.client.inviteIntoChat(chatId, mids);
+            return { invited: true, chatId, mids };
+        },
+        /**
+         * Remove (kick) members from a group/chat (TalkService
+         * deleteOtherFromChat).
+         *
+         * @param chatId - Group/chat MID.
+         * @param mids - Member MIDs to remove.
+         * @returns `{ removed, chatId, mids }`.
+         */
+        async kickFromGroup(chatId, mids) {
+            await service.client.deleteOtherFromChat(chatId, mids);
+            return { removed: true, chatId, mids };
+        },
+        /**
+         * Leave a group/chat — the authenticated account itself exits (TalkService
+         * deleteSelfFromChat).
+         *
+         * @param chatId - Group/chat MID to leave.
+         * @returns `{ left, chatId }`.
+         */
+        async leaveGroup(chatId) {
+            await service.client.deleteSelfFromChat(chatId);
+            return { left: true, chatId };
+        },
+        /**
+         * Create a new group/room with an initial member set (TalkService
+         * createChat). Does not mint any E2EE group key.
+         *
+         * @param name - New chat name.
+         * @param mids - Initial member MIDs.
+         * @param chatType - LINE chat type (0 = group, 1 = room). Default 1.
+         * @returns `{ created, chatId, name, chat }`.
+         */
+        async createGroup(name, mids, chatType = 1) {
+            const chat = await service.client.createChat(name, mids, chatType);
+            // The created Chat struct carries its MID at thrift field 2 (see
+            // mapChatStruct in chat-query.ts); field 6 is the name.
+            return {
+                created: true,
+                chatId: chat?.[2] ?? chat?.chatMid ?? null,
+                name,
+                chat,
+            };
+        },
+        /**
+         * Add a predefined reaction to a message (TalkService react).
+         *
+         * @param messageId - Target message id.
+         * @param reactionType - Predefined reaction type (2=LIKE, 3=LOVE, 4=LAUGH,
+         * 5=SURPRISE, 6=SAD, 7=ANGRY). Default 2.
+         * @returns `{ reacted, messageId, reactionType }`.
+         */
+        async reactToMessage(messageId, reactionType = 2) {
+            await service.client.react(messageId, reactionType);
+            return { reacted: true, messageId, reactionType };
+        },
+        /**
+         * Remove this account's reaction from a message (TalkService
+         * cancelReaction).
+         *
+         * @param messageId - Target message id.
+         * @returns `{ cancelled, messageId }`.
+         */
+        async cancelReaction(messageId) {
+            await service.client.cancelReaction(messageId);
+            return { cancelled: true, messageId };
+        },
+        /**
+         * Unsend (retract) one of this account's own messages for everyone
+         * (TalkService unsendMessage). LINE only permits unsending own messages.
+         *
+         * @param messageId - Message id to unsend.
+         * @returns `{ unsent, messageId }`.
+         */
+        async unsendMessage(messageId) {
+            await service.client.unsendMessage(messageId);
+            return { unsent: true, messageId };
+        },
+        /**
+         * Add a friend by MID (TalkService findAndAddContactsByMid).
+         *
+         * @param mid - MID of the person to add.
+         * @param reference - Optional JSON reference breadcrumb.
+         * @returns `{ added, mid, contact }`.
+         */
+        async addFriend(mid, reference) {
+            const contact = await service.client.findAndAddContactByMid(mid, reference);
+            return { added: true, mid, contact };
+        },
+        /**
+         * Block a contact (TalkService blockContact).
+         *
+         * @param mid - Contact MID to block.
+         * @returns `{ blocked, mid }`.
+         */
+        async blockContact(mid) {
+            await service.client.blockContact(mid);
+            return { blocked: true, mid };
+        },
+        /**
+         * Unblock a contact (TalkService unblockContact).
+         *
+         * @param mid - Contact MID to unblock.
+         * @returns `{ unblocked, mid }`.
+         */
+        async unblockContact(mid) {
+            await service.client.unblockContact(mid);
+            return { unblocked: true, mid };
+        },
+        /**
+         * Accept a group/chat invitation — this account joins the chat (TalkService
+         * acceptChatInvitation).
+         *
+         * @param chatMid - Group/chat MID to accept.
+         * @returns `{ accepted, chatId }`.
+         */
+        async acceptInvitation(chatMid) {
+            await service.client.acceptChatInvitation(chatMid);
+            return { accepted: true, chatId: chatMid };
+        },
+    };
+}

package/dist/line/core/client-runtime.js

@@ -0,0 +1,17 @@
+/**
+ * LINE core runtime accessors.
+ */
+/**
+ * Resolve the active LINE client or fail fast when the protocol service has
+ * not established a session yet.
+ *
+ * @param getClient - Deferred LINE client accessor
+ * @returns Connected LINE client instance
+ */
+export function requireLineClient(getClient) {
+    const client = getClient();
+    if (!client) {
+        throw new Error('Not connected');
+    }
+    return client;
+}