@rikaidev/yomi 0.2.6

package/dist/line/client/index.js

@@ -0,0 +1,213 @@
+/**
+ * LINE Client — TalkService API
+ *
+ * Core class with transport layer. Domain capabilities are composed
+ * from separate modules (DDD bounded contexts):
+ *   - auth-service/    — AuthService: refresh, logout, bootstrap flows
+ *   - talk-service/    — TalkService read/write capabilities
+ *   - sync-service/    — Polling: sync, longPoll, startPolling
+ *   - e2ee-service/    — E2EE transport capabilities
+ *   - shop-service/    — ShopService: owned sticker packages
+ *
+ * Endpoints:
+ *   /AS4    — AuthService
+ *   /S4     — TalkService
+ *   /SYNC4  — SyncService
+ *   /TSHOP4 — ShopService
+ */
+import { EventEmitter } from 'node:events';
+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 { createE2EEClient } from './e2ee-service/client.js';
+import { parseOperation } from './parsers.js';
+import { createShopClient } from './shop-service/client.js';
+import { createSyncClient } from './sync-service/client.js';
+import { createTalkCommandClient } from './talk-service/command-client.js';
+import { createTalkQueryClient } from './talk-service/query-client.js';
+import { sendRequest } from './transport.js';
+const TALK_EXCEPTION_CODE_NAMES = {
+    5: 'NOT_FOUND',
+};
+const LINE_AUTH_INVALIDATED_PATTERN = /V3_TOKEN_CLIENT_LOGGED_OUT|LOGGED_OUT|DIVESTED/i;
+/**
+ * LINE request error aligned with the shape used by linejs InternalError.
+ *
+ * @param type - Error type/category
+ * @param message - Human-readable diagnostic message
+ * @param data - Structured exception payload
+ */
+export class LineRequestError extends Error {
+    data;
+    type;
+    constructor(type, message, data = {}) {
+        super(message);
+        this.name = type;
+        this.type = type;
+        this.data = data;
+    }
+}
+/**
+ * Detect LINE auth invalidation errors returned after a previously successful login.
+ *
+ * @param error - Runtime error thrown by LINE TalkService calls.
+ * @returns Whether LINE has invalidated the current client token.
+ */
+export function isLineAuthInvalidatedError(error) {
+    const data = error?.data;
+    const exceptionMessage = data?.exception && typeof data.exception === 'object'
+        ? String(data.exception['2'] || '')
+        : '';
+    const message = error instanceof Error ? error.message : String(error || '');
+    return LINE_AUTH_INVALIDATED_PATTERN.test(`${message} ${exceptionMessage}`);
+}
+/**
+ * Resolve the active LINE client logger, preserving startup indentation.
+ *
+ * @param client - LINE client instance.
+ * @returns Logger for transport and request diagnostics.
+ */
+function getLineClientLog(client) {
+    if (client?.startupFlowLogger) {
+        return client.startupFlowLogger;
+    }
+    if (client?.logger?.info) {
+        return client.logger;
+    }
+    return client?.logger || createCliLogger('LINE');
+}
+/**
+ * Normalize one raw TalkException payload into a linejs-like error shape.
+ *
+ * @param exception - Decoded thrift exception struct from field 1
+ * @returns Normalized code/message/rawCode tuple
+ */
+function normalizeTalkException(exception) {
+    const rawCode = exception?.[1];
+    const numericCode = typeof rawCode === 'number'
+        ? rawCode
+        : typeof rawCode === 'bigint'
+            ? Number(rawCode)
+            : null;
+    const code = numericCode != null
+        ? TALK_EXCEPTION_CODE_NAMES[numericCode] || String(numericCode)
+        : typeof rawCode === 'string'
+            ? rawCode
+            : 'UNKNOWN';
+    const message = typeof exception?.[2] === 'string'
+        ? exception[2]
+        : JSON.stringify(exception);
+    return {
+        code,
+        message,
+        rawCode,
+    };
+}
+/**
+ * LINE protocol client. Communicates with LINE servers via TCompact over HTTPS.
+ *
+ * @param authToken - The LINE authentication token
+ * @param config - Configuration options
+ */
+export class LineClient extends EventEmitter {
+    authToken;
+    host;
+    profile;
+    revision;
+    globalRevision;
+    individualRevision;
+    polling;
+    aborted;
+    seq;
+    logger;
+    startupFlowLogger;
+    // The following are mixed in at construction time via Object.assign from
+    // the auth/talk/sync/e2ee service factories (see constructor below) — TS
+    // cannot see that assignment, so these use definite-assignment assertions.
+    openAuthSession;
+    issueV3TokenForPrimary;
+    restoreE2EEKeyBackup;
+    downloadMessageContent;
+    downloadMessageContentPreview;
+    logoutZ;
+    getOwnedStickerPackages;
+    updateChatName;
+    inviteIntoChat;
+    deleteOtherFromChat;
+    deleteSelfFromChat;
+    createChat;
+    react;
+    cancelReaction;
+    unsendMessage;
+    findAndAddContactByMid;
+    blockContact;
+    unblockContact;
+    acceptChatInvitation;
+    constructor(authToken, config = {}) {
+        super();
+        this.authToken = authToken;
+        this.host = config.host || LINE_APP_CONFIG.host;
+        this.revision = config.revision ?? -1;
+        this.globalRevision = config.globalRevision ?? 0;
+        this.individualRevision = config.individualRevision ?? 0;
+        this.polling = false;
+        this.aborted = false;
+        this.profile = null;
+        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));
+    }
+    /**
+     * Send a TCompact Thrift call to an arbitrary LINE service endpoint path.
+     * sendTalk is the /S4 (TalkService) special case; other services (e.g. the
+     * unified shop at /TSHOP4) share the same envelope, auth header, and
+     * token-rotation/exception handling.
+     *
+     * @param path - Service endpoint path (e.g. /S4, /TSHOP4).
+     * @param method - Thrift method name.
+     * @param args - Method arguments as Thrift field tuples.
+     * @returns The decoded server response.
+     */
+    async sendCompact(path, method, args) {
+        const data = encodeCallMessage(method, this.seq++, args);
+        const result = await sendRequest(this.host, path, data, { 'X-Line-Access': this.authToken }, 30000, { logger: getLineClientLog(this) });
+        if (result.nextToken) {
+            getLineClientLog(this).info('auth.token_rotated', { method });
+            this.authToken = result.nextToken;
+            this.emit('tokenRotated', result.nextToken);
+        }
+        if (result.fields?.[1] && typeof result.fields[1] === 'object') {
+            const exc = result.fields[1];
+            const normalized = normalizeTalkException(exc);
+            throw new LineRequestError('RequestError', `Request internal failed, ${method}(${path}) -> ${normalized.message}`, {
+                code: normalized.code,
+                rawCode: normalized.rawCode,
+                method,
+                path,
+                exception: exc,
+            });
+        }
+        return result;
+    }
+    /**
+     * Send a TalkService (/S4) request to the LINE server.
+     *
+     * @param method - The TalkService method name
+     * @param args - The method arguments as Thrift field tuples
+     * @returns The decoded server response
+     */
+    async sendTalk(method, args) {
+        return this.sendCompact(LINE_APP_CONFIG.talkPath, method, args);
+    }
+    /**
+     * Parse a raw Thrift operation struct into a domain object.
+     *
+     * @param op - Raw operation data
+     * @returns Parsed operation or null
+     */
+    parseOperation(op) {
+        return parseOperation(op);
+    }
+}

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

@@ -0,0 +1,140 @@
+import { Buffer } from 'node:buffer';
+import { randomUUID } from 'node:crypto';
+import https from 'node:https';
+import { LINE_APP_CONFIG } from '../core/config.js';
+import { TBinaryWriter } from '../core/thrift/binary/binary-writer.js';
+import { THRIFT_TYPE } from '../core/thrift/types.js';
+const OBS_HOST = 'obs.line-apps.com';
+// Uploads do NOT go to the OBS domain — they POST through the LINE gateway
+// (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';
+/**
+ * Build LINE talk metadata required for OBS media downloads.
+ *
+ * @param messageId - LINE message id.
+ * @returns Base64 encoded X-Talk-Meta header.
+ */
+function buildTalkMeta(messageId) {
+    const writer = new TBinaryWriter();
+    writer.writeFieldBegin(4, THRIFT_TYPE.STRING);
+    writer.writeString(messageId);
+    writer.writeFieldBegin(27, THRIFT_TYPE.LIST);
+    writer.writeList(THRIFT_TYPE.STRUCT, []);
+    writer.writeFieldStop();
+    const message = Buffer.from(writer.getBuffer()).toString('base64');
+    return Buffer.from(JSON.stringify({ message })).toString('base64');
+}
+/**
+ * Download one LINE OBS media object.
+ *
+ * @param client - LINE protocol client.
+ * @param options - OBS object options.
+ * @param options.messageId - LINE message id.
+ * @param options.oid - Object id.
+ * @param options.sid - Service namespace.
+ * @param options.preview - Whether to fetch the preview object.
+ * @returns Downloaded encrypted bytes.
+ */
+export function downloadLineObsMediaObject(client, options) {
+    const oid = options.preview ? `${options.oid}__ud-preview` : options.oid;
+    const requestPath = `/r/talk/${options.sid}/${oid}`;
+    const headers = {
+        'User-Agent': LINE_APP_CONFIG.userAgent,
+        'X-Line-Access': client.authToken,
+        'X-Line-Application': LINE_APP_CONFIG.lineApp,
+        'X-Talk-Meta': buildTalkMeta(options.messageId),
+        accept: 'application/x-thrift',
+        'accept-encoding': 'gzip',
+        'x-lal': 'ja_JP',
+        'x-lhm': 'GET',
+        'x-lpv': '1',
+    };
+    return new Promise((resolve, reject) => {
+        const request = https.request({
+            headers,
+            hostname: OBS_HOST,
+            method: 'GET',
+            path: requestPath,
+            port: 443,
+            timeout: 30000,
+        }, (response) => {
+            const chunks = [];
+            response.on('data', (chunk) => chunks.push(chunk));
+            response.on('end', () => {
+                const body = Buffer.concat(chunks);
+                if (!response.statusCode || response.statusCode >= 400) {
+                    reject(new Error(`LINE OBS download failed: status=${response.statusCode || 'unknown'} bytes=${body.length}`));
+                    return;
+                }
+                resolve(body);
+            });
+        });
+        request.on('timeout', () => {
+            request.destroy();
+            reject(new Error('LINE OBS download timed out'));
+        });
+        request.on('error', reject);
+        request.end();
+    });
+}
+/**
+ * Upload one LINE OBS media object (image bytes, or its preview object).
+ *
+ * Mirrors {@link downloadLineObsMediaObject}'s auth/header scheme, swapped
+ * to a POST body upload. Callers are responsible for encrypting `data`
+ * (ciphertext‖MAC) before calling this — this function performs no
+ * encryption of its own.
+ *
+ * @param options - OBS object options.
+ * @param options.sid - Service namespace (e.g. 'emi' for image).
+ * @param options.objectPath - Object path segment (e.g. `reqid-<uuid>`, or `<oid>__ud-preview`).
+ * @param options.data - Encrypted bytes to upload as the request body.
+ * @param options.mid - Authenticated self MID (sent as X-Line-Mid).
+ * @param options.accessToken - Encrypted access token (acquireEncryptedAccessToken, `\x1e`-split index 1); the gateway rejects the plain session JWT.
+ * @param options.params - Extra fields merged into the X-Obs-Params header.
+ * @returns The server-assigned object id and content hash.
+ */
+export async function uploadLineObsMediaObject(options) {
+    // Uploads POST to the LINE gateway (OBS_UPLOAD_HOST) at /oa/r/talk/{sid}/{oid}
+    // — a different host AND route than downloads (obs.line-apps.com /r/talk/...).
+    // The gateway requires the encrypted access token (not the session JWT), an
+    // application/octet-stream body, AND HTTP/2: over HTTP/1.1 (node:https) it
+    // returns 503, so this uses fetch, which negotiates h2 via ALPN. Verified
+    // live against the real gateway (201 Created). The download-only x-lhm/x-lpv
+    // are absent.
+    const requestUrl = `https://${OBS_UPLOAD_HOST}/oa/r/talk/${options.sid}/${options.objectPath}`;
+    // The gateway requires `type` and `name` in X-Obs-Params on EVERY upload,
+    // including the preview subresource — a request missing `name` is rejected
+    // (400 without name, 503 with neither name nor type). Defaults are supplied
+    // here so callers (e.g. the preview upload) need not repeat them; explicit
+    // params still override.
+    const obsParams = {
+        type: 'file',
+        ver: '2.0',
+        name: randomUUID(),
+        ...(options.params ?? {}),
+    };
+    const headers = {
+        'User-Agent': LINE_APP_CONFIG.userAgent,
+        'X-Line-Access': options.accessToken,
+        'X-Line-Application': LINE_APP_CONFIG.lineApp,
+        'X-Line-Mid': options.mid,
+        'X-Obs-Params': Buffer.from(JSON.stringify(obsParams)).toString('base64'),
+        'Content-Type': 'application/octet-stream',
+        'x-lal': 'ja_JP',
+    };
+    const response = await fetch(requestUrl, {
+        method: 'POST',
+        headers,
+        body: options.data,
+    });
+    if (response.status !== 200 && response.status !== 201) {
+        throw new Error(`LINE OBS upload failed: status=${response.status}`);
+    }
+    const oid = response.headers.get('x-obs-oid');
+    if (!oid) {
+        throw new Error(`LINE OBS upload succeeded but response is missing x-obs-oid header (status=${response.status})`);
+    }
+    return { oid, hash: response.headers.get('x-obs-hash') };
+}

package/dist/line/client/parsers.js

@@ -0,0 +1,69 @@
+/**
+ * LINE Protocol Message & Operation Parsers
+ *
+ * Transforms raw Thrift structs into domain objects.
+ * Pure functions — no side effects, no network calls.
+ */
+/**
+ * Parse a raw Thrift message struct into a domain object.
+ *
+ * @param msg - Raw Thrift message struct
+ * @returns Parsed message or null if invalid
+ */
+export function parseMessage(msg) {
+    if (!msg || typeof msg !== 'object') {
+        return null;
+    }
+    return {
+        id: msg[4] || null,
+        from: msg[1] || null,
+        to: msg[2] || null,
+        toType: msg[3],
+        createdTime: typeof msg[5] === 'bigint' ? Number(msg[5]) : msg[5],
+        deliveredTime: typeof msg[6] === 'bigint'
+            ? Number(msg[6])
+            : typeof msg[7] === 'bigint'
+                ? Number(msg[7])
+                : (msg[6] ?? msg[7]),
+        text: msg[10] || null,
+        contentType: msg[15] || 0,
+        contentMetadata: msg[18] || {},
+        chunks: msg[20] || null,
+    };
+}
+/**
+ * Parse raw message data into an array of message objects.
+ *
+ * @param data - Raw message data (array or single struct)
+ * @returns Array of parsed message objects
+ */
+export function parseMessages(data) {
+    if (Array.isArray(data)) {
+        return data.map((m) => parseMessage(m)).filter(Boolean);
+    }
+    if (data && typeof data === 'object') {
+        return [parseMessage(data)].filter(Boolean);
+    }
+    return [];
+}
+/**
+ * Parse a raw Thrift operation struct into a domain object.
+ *
+ * @param op - Raw Thrift operation struct
+ * @returns Parsed operation or null if invalid
+ */
+export function parseOperation(op) {
+    if (!op || typeof op !== 'object') {
+        return null;
+    }
+    return {
+        revision: typeof op[1] === 'bigint' ? Number(op[1]) : op[1],
+        createdTime: typeof op[2] === 'bigint' ? Number(op[2]) : op[2],
+        type: op[3],
+        reqSeq: op[4],
+        param1: op[10] || null,
+        param2: op[11] || null,
+        param3: op[12] || null,
+        message: op[20] && typeof op[20] === 'object' ? parseMessage(op[20]) : null,
+    };
+}

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

@@ -0,0 +1,63 @@
+/**
+ * LINE ShopService capability — the unified shop at /TSHOP4.
+ *
+ * Only the sticker-ownership read is implemented: getOwnedProductSummaries with
+ * shopId "stickershop" returns the sticker PACKAGES the authenticated account
+ * owns (and can therefore send — LINE rejects sending a non-owned sticker with
+ * "sticker is not owned by the user"). Response summary fields used: 1 =
+ * packageId, 11 = title, 21 = version. Field 3 of the return is the total count,
+ * used to paginate.
+ */
+import { i32Field, stringField, structField } from '../../core/thrift/index.js';
+/** Sticker shop id for the unified shop's getOwnedProductSummaries. */
+const STICKER_SHOP_ID = 'stickershop';
+/** Unified shop endpoint. */
+const SHOP_PATH = '/TSHOP4';
+/**
+ * Create the ShopService capability bound to one LINE client runtime.
+ *
+ * @param runtime - LINE client runtime exposing sendCompact.
+ * @returns Shop query methods bound to the runtime.
+ */
+export function createShopClient(runtime) {
+    return {
+        /**
+         * List the sticker packages the authenticated account owns, paginating
+         * until the server's reported total is reached.
+         *
+         * @param language - BCP-47-ish language for titles (default 'en').
+         * @param country - Country code for the shop locale (default 'TW').
+         * @returns Owned sticker packages.
+         */
+        async getOwnedStickerPackages(language = 'en', country = 'TW') {
+            const packages = [];
+            const limit = 200;
+            let total = Number.POSITIVE_INFINITY;
+            while (packages.length < total) {
+                const res = await runtime.sendCompact(SHOP_PATH, 'getOwnedProductSummaries', [
+                    stringField(2, STICKER_SHOP_ID),
+                    i32Field(3, packages.length),
+                    i32Field(4, limit),
+                    structField(5, [stringField(1, language), stringField(2, country)]),
+                ]);
+                const ret = res?.fields?.[0];
+                const summaries = Array.isArray(ret?.[1]) ? ret[1] : [];
+                total = Number(ret?.[3] ?? summaries.length);
+                for (const s of summaries) {
+                    if (s?.[1] == null) {
+                        continue;
+                    }
+                    packages.push({
+                        packageId: String(s[1]),
+                        title: String(s[11] ?? ''),
+                        version: String(s[21] ?? '1'),
+                    });
+                }
+                if (summaries.length === 0 || summaries.length < limit) {
+                    break;
+                }
+            }
+            return packages;
+        },
+    };
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Sticker package metadata from LINE's PUBLIC sticker CDN.
+ *
+ * getOwnedStickerPackages (ShopService) returns package-level info; to actually
+ * send a sticker LINE needs an individual sticker id (STKID). Those live in the
+ * package's public productInfo.meta on the sticker CDN — no auth, no account
+ * data sent (only the public packageId), so this is safe to fetch for any owned
+ * package the caller wants to expand into sendable sticker ids.
+ */
+const CDN = 'https://stickershop.line-scdn.net/stickershop/v1/product';
+/**
+ * Fetch one sticker package's public metadata (title + individual sticker ids).
+ *
+ * @param packageId - LINE sticker package id (STKPKGID).
+ * @returns Package metadata, or null when the CDN has no such package.
+ */
+export async function fetchStickerPackageMeta(packageId) {
+    const res = await fetch(`${CDN}/${packageId}/android/productInfo.meta`);
+    if (!res.ok) {
+        return null;
+    }
+    const meta = await res.json();
+    const stickers = Array.isArray(meta?.stickers) ? meta.stickers : [];
+    return {
+        packageId: String(meta?.packageId ?? packageId),
+        title: meta?.title && typeof meta.title === 'object'
+            ? meta.title
+            : {},
+        stickerIds: stickers
+            .map((s) => (s?.id != null ? String(s.id) : null))
+            .filter((id) => id !== null),
+    };
+}
+/**
+ * Fetch one sticker's PNG preview image from the public sticker CDN.
+ *
+ * @param stickerId - LINE sticker id (STKID).
+ * @returns PNG bytes, or null when the CDN has no such sticker.
+ */
+export async function fetchStickerImage(stickerId) {
+    const res = await fetch(`${CDN.replace('/product', '/sticker')}/${stickerId}/android/sticker.png`);
+    if (!res.ok) {
+        return null;
+    }
+    return Buffer.from(await res.arrayBuffer());
+}