@kin-tio/cli 0.6.0

package/dist/src/ilink/media.js

@@ -0,0 +1,267 @@
+import { createCipheriv, createHash, randomBytes, } from 'node:crypto';
+import { detectImageFormat } from '../lib/image-format.js';
+import { IlinkMessageItemType } from './protocol/types.js';
+/**
+ * This in-memory upload flow was independently rewritten after reviewing the
+ * MIT-licensed @tencent-weixin/openclaw-weixin 2.4.6 CDN implementation. It
+ * deliberately omits that package's local-file and remote-URL helpers.
+ * See THIRD_PARTY_NOTICES for attribution.
+ */
+export const MAX_ILINK_IMAGE_BYTES = 2 * 1024 * 1024;
+export const DEFAULT_ILINK_MEDIA_TIMEOUT_MS = 15_000;
+const MAX_MEDIA_TIMEOUT_MS = 60_000;
+const MAX_PEER_ID_BYTES = 1_024;
+const MAX_OPAQUE_PARAM_BYTES = 256 * 1024;
+const MAX_UPLOAD_URL_BYTES = 512 * 1024;
+const ILINK_CDN_HOST = 'novac2c.cdn.weixin.qq.com';
+const ILINK_CDN_UPLOAD_URL = `https://${ILINK_CDN_HOST}/c2c/upload`;
+const VISIBLE_ASCII = /^[\x21-\x7e]+$/u;
+const IlinkUploadMediaType = {
+    IMAGE: 1,
+};
+export class IlinkMediaError extends Error {
+    code;
+    status;
+    constructor(code, message, details = {}) {
+        super(message, details.cause === undefined ? undefined : { cause: details.cause });
+        this.name = 'IlinkMediaError';
+        this.code = code;
+        this.status = details.status;
+    }
+}
+function mediaError(code, message, details) {
+    return new IlinkMediaError(code, message, details);
+}
+function normalizeTimeout(value) {
+    if (!Number.isSafeInteger(value) ||
+        value < 1 ||
+        value > MAX_MEDIA_TIMEOUT_MS) {
+        throw mediaError('invalid_timeout', `iLink media timeout must be between 1 and ${MAX_MEDIA_TIMEOUT_MS} milliseconds`);
+    }
+    return value;
+}
+function normalizePeerId(value) {
+    if (typeof value !== 'string' ||
+        !value ||
+        value !== value.trim() ||
+        Buffer.byteLength(value, 'utf8') > MAX_PEER_ID_BYTES ||
+        /[\u0000-\u001f\u007f]/u.test(value)) {
+        throw mediaError('invalid_peer', 'Invalid iLink image recipient');
+    }
+    return value;
+}
+function copyAndValidateImage(value) {
+    if (!Buffer.isBuffer(value) || value.length === 0 || !detectImageFormat(value)) {
+        throw mediaError('invalid_image', 'Invalid iLink image bytes');
+    }
+    if (value.length > MAX_ILINK_IMAGE_BYTES) {
+        throw mediaError('image_too_large', `iLink image exceeds the ${MAX_ILINK_IMAGE_BYTES}-byte limit`);
+    }
+    return Buffer.from(value);
+}
+function validateAesKey(key) {
+    if (!Buffer.isBuffer(key) || key.length !== 16) {
+        throw mediaError('invalid_image', 'iLink media AES key must contain 16 bytes');
+    }
+}
+/** AES-128-ECB encryption with the PKCS#7 padding enabled by Node by default. */
+export function encryptIlinkMedia(plaintext, key) {
+    if (!Buffer.isBuffer(plaintext)) {
+        throw mediaError('invalid_image', 'Invalid iLink media bytes');
+    }
+    validateAesKey(key);
+    const cipher = createCipheriv('aes-128-ecb', key, null);
+    return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+export function ilinkAesEcbPaddedSize(plaintextSize) {
+    if (!Number.isSafeInteger(plaintextSize) || plaintextSize < 0) {
+        throw mediaError('invalid_image', 'Invalid iLink media size');
+    }
+    return Math.ceil((plaintextSize + 1) / 16) * 16;
+}
+function opaqueParameter(value, label) {
+    if (typeof value !== 'string' ||
+        !value ||
+        value !== value.trim() ||
+        Buffer.byteLength(value, 'utf8') > MAX_OPAQUE_PARAM_BYTES ||
+        !VISIBLE_ASCII.test(value)) {
+        throw mediaError('invalid_upload_response', `Invalid iLink ${label}`);
+    }
+    return value;
+}
+function validateCdnUploadUrl(value) {
+    if (!value ||
+        value !== value.trim() ||
+        Buffer.byteLength(value, 'utf8') > MAX_UPLOAD_URL_BYTES) {
+        throw mediaError('unsafe_upload_url', 'Unsafe iLink CDN upload URL');
+    }
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw mediaError('unsafe_upload_url', 'Unsafe iLink CDN upload URL');
+    }
+    if (url.protocol !== 'https:' ||
+        url.hostname !== ILINK_CDN_HOST ||
+        url.username ||
+        url.password ||
+        url.port ||
+        url.pathname !== '/c2c/upload' ||
+        !url.search ||
+        url.hash) {
+        throw mediaError('unsafe_upload_url', 'Unsafe iLink CDN upload URL');
+    }
+    return url;
+}
+function resolveUploadUrl(value, filekey) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw mediaError('invalid_upload_response', 'Invalid iLink upload response');
+    }
+    const response = value;
+    const fullUrl = response.upload_full_url;
+    if (fullUrl !== undefined && typeof fullUrl !== 'string') {
+        throw mediaError('invalid_upload_response', 'Invalid iLink upload_full_url');
+    }
+    if (typeof fullUrl === 'string' && fullUrl !== '') {
+        return validateCdnUploadUrl(fullUrl);
+    }
+    const uploadParam = opaqueParameter(response.upload_param, 'upload_param');
+    const fallback = new URL(ILINK_CDN_UPLOAD_URL);
+    fallback.searchParams.set('encrypted_query_param', uploadParam);
+    fallback.searchParams.set('filekey', filekey);
+    return fallback;
+}
+function createRequestControl(externalSignal, timeoutMs) {
+    const controller = new AbortController();
+    const onExternalAbort = () => {
+        controller.abort(mediaError('aborted', 'iLink image upload was aborted'));
+    };
+    if (externalSignal?.aborted) {
+        onExternalAbort();
+    }
+    else {
+        externalSignal?.addEventListener('abort', onExternalAbort, { once: true });
+    }
+    const timer = setTimeout(() => {
+        controller.abort(mediaError('timeout', 'iLink image upload timed out'));
+    }, timeoutMs);
+    timer.unref();
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            clearTimeout(timer);
+            externalSignal?.removeEventListener('abort', onExternalAbort);
+        },
+    };
+}
+function abortReason(signal) {
+    return signal.reason instanceof IlinkMediaError
+        ? signal.reason
+        : mediaError('aborted', 'iLink image upload was aborted');
+}
+async function abortable(promise, signal) {
+    if (signal.aborted)
+        throw abortReason(signal);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortReason(signal));
+        signal.addEventListener('abort', onAbort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+function imageMessageItem({ encryptedParameter, aesKey, ciphertextSize, }) {
+    return Object.freeze({
+        type: IlinkMessageItemType.IMAGE,
+        image_item: Object.freeze({
+            media: Object.freeze({
+                encrypt_query_param: encryptedParameter,
+                aes_key: Buffer.from(aesKey.toString('hex'), 'ascii').toString('base64'),
+                encrypt_type: 1,
+            }),
+            mid_size: ciphertextSize,
+        }),
+    });
+}
+/**
+ * Encrypt and upload image bytes, then produce the IMAGE MessageItem accepted
+ * by sendmessage. Only caller-provided memory is accepted as image input.
+ */
+export async function uploadIlinkImageBuffer({ bytes, peerId, client, fetchImpl = globalThis.fetch, signal: externalSignal, timeoutMs: rawTimeoutMs = DEFAULT_ILINK_MEDIA_TIMEOUT_MS, }) {
+    const plaintext = copyAndValidateImage(bytes);
+    const recipient = normalizePeerId(peerId);
+    const timeoutMs = normalizeTimeout(rawTimeoutMs);
+    if (typeof client?.getUploadUrl !== 'function') {
+        throw mediaError('get_upload_url_failed', 'iLink upload client is unavailable');
+    }
+    if (typeof fetchImpl !== 'function') {
+        throw mediaError('upload_failed', 'iLink CDN transport is unavailable');
+    }
+    const aesKey = randomBytes(16);
+    const filekey = randomBytes(16).toString('hex');
+    const ciphertext = encryptIlinkMedia(plaintext, aesKey);
+    const request = Object.freeze({
+        filekey,
+        media_type: IlinkUploadMediaType.IMAGE,
+        to_user_id: recipient,
+        rawsize: plaintext.length,
+        rawfilemd5: createHash('md5').update(plaintext).digest('hex'),
+        filesize: ilinkAesEcbPaddedSize(plaintext.length),
+        no_need_thumb: true,
+        aeskey: aesKey.toString('hex'),
+    });
+    const control = createRequestControl(externalSignal, timeoutMs);
+    try {
+        let uploadDetails;
+        try {
+            uploadDetails = await abortable(client.getUploadUrl(request, { signal: control.signal, timeoutMs }), control.signal);
+        }
+        catch (error) {
+            if (control.signal.aborted)
+                throw abortReason(control.signal);
+            throw mediaError('get_upload_url_failed', 'Could not obtain an iLink CDN upload URL', { cause: error });
+        }
+        const uploadUrl = resolveUploadUrl(uploadDetails, filekey);
+        let response;
+        try {
+            response = await abortable(fetchImpl(uploadUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/octet-stream' },
+                body: new Uint8Array(ciphertext),
+                redirect: 'error',
+                signal: control.signal,
+            }), control.signal);
+        }
+        catch (error) {
+            if (control.signal.aborted)
+                throw abortReason(control.signal);
+            throw mediaError('upload_failed', 'iLink CDN upload failed', { cause: error });
+        }
+        if (response.redirected) {
+            throw mediaError('unsafe_upload_url', 'iLink CDN redirects are forbidden');
+        }
+        if (response.url) {
+            const responseUrl = validateCdnUploadUrl(response.url);
+            if (responseUrl.href !== uploadUrl.href) {
+                throw mediaError('unsafe_upload_url', 'iLink CDN response URL changed');
+            }
+        }
+        if (response.status !== 200) {
+            throw mediaError('upload_rejected', `iLink CDN rejected the upload with HTTP ${response.status}`, { status: response.status });
+        }
+        const encryptedParameter = opaqueParameter(response.headers.get('x-encrypted-param'), 'x-encrypted-param');
+        return imageMessageItem({
+            encryptedParameter,
+            aesKey,
+            ciphertextSize: ciphertext.length,
+        });
+    }
+    finally {
+        control.cleanup();
+    }
+}

package/dist/src/ilink/message.js

@@ -0,0 +1,247 @@
+import { createHash } from 'node:crypto';
+import { MESSAGE_ORIGINS } from '../domain/message.js';
+import { truncateUtf8 } from '../lib/text.js';
+import { IlinkMessageItemType, IlinkMessageState, IlinkMessageType, } from './protocol/types.js';
+import { extractIlinkInboundImageLocator } from './inbound-image.js';
+import { ILINK_ACCOUNT_KEY_PATTERN, ILINK_CHANNEL, ILINK_MAX_PROVIDER_ID_BYTES, } from './store-types.js';
+const MAX_ID_CHARACTERS = 1_024;
+const MAX_CURSOR_CHARACTERS = 256 * 1_024;
+const MAX_CONTEXT_TOKEN_CHARACTERS = 256 * 1_024;
+const MAX_ITEMS = 50;
+const MAX_TEXT_BYTES = 32 * 1_024;
+const MAX_SUMMARY_BYTES = 48 * 1_024;
+const MAX_NATIVE_IMAGES = 4;
+export class IlinkMessageNormalizationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'IlinkMessageNormalizationError';
+        this.code = code;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function requiredBoundedString(value, label, maximum, code) {
+    if (typeof value !== 'string' ||
+        !value ||
+        value.length > maximum ||
+        value.includes('\0')) {
+        throw new IlinkMessageNormalizationError(code, `${label} is invalid`);
+    }
+    return value;
+}
+function normalizePair(pair) {
+    const accountKey = requiredBoundedString(pair?.accountKey, 'iLink accountKey', MAX_ID_CHARACTERS, 'invalid_pair');
+    if (!ILINK_ACCOUNT_KEY_PATTERN.test(accountKey)) {
+        throw new IlinkMessageNormalizationError('invalid_pair', 'iLink accountKey is invalid');
+    }
+    const providerId = (value, label) => {
+        if (typeof value !== 'string' ||
+            !value ||
+            value !== value.trim() ||
+            Buffer.byteLength(value, 'utf8') > ILINK_MAX_PROVIDER_ID_BYTES ||
+            /[\u0000-\u001f\u007f]/u.test(value)) {
+            throw new IlinkMessageNormalizationError('invalid_pair', `${label} is invalid`);
+        }
+        return value;
+    };
+    return Object.freeze({
+        accountKey: accountKey,
+        botId: providerId(pair?.botId, 'iLink botId'),
+        ownerUserId: providerId(pair?.ownerUserId, 'iLink ownerUserId'),
+    });
+}
+function normalizeSync(sync) {
+    const cursor = sync?.cursor;
+    if (typeof cursor !== 'string' ||
+        cursor.length > MAX_CURSOR_CHARACTERS ||
+        cursor.includes('\0')) {
+        throw new IlinkMessageNormalizationError('invalid_sync', 'iLink cursor is invalid');
+    }
+    if (!Number.isSafeInteger(sync?.index) || sync.index < 0) {
+        throw new IlinkMessageNormalizationError('invalid_sync', 'iLink cursor index is invalid');
+    }
+    return Object.freeze({ cursor, index: sync.index });
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function stableString(value) {
+    return typeof value === 'string' && value &&
+        value.length <= MAX_ID_CHARACTERS && !value.includes('\0')
+        ? value
+        : '';
+}
+function providerMessageId(message) {
+    if (Number.isSafeInteger(message.message_id) &&
+        Number(message.message_id) >= 0) {
+        return `message:${message.message_id}`;
+    }
+    const clientId = stableString(message.client_id);
+    if (clientId)
+        return `client:${sha256(clientId)}`;
+    const itemIds = (message.item_list ?? [])
+        .map((item) => stableString(isRecord(item) ? item.msg_id : undefined))
+        .filter(Boolean);
+    if (itemIds.length > 0) {
+        return `items:${sha256(JSON.stringify(itemIds))}`;
+    }
+    if (Number.isSafeInteger(message.seq) && Number(message.seq) >= 0) {
+        return `seq:${message.seq}`;
+    }
+    return undefined;
+}
+function safeFilename(value) {
+    return truncateUtf8(typeof value === 'string'
+        ? value.replace(/[\u0000-\u001f\u007f]+/gu, ' ').replace(/\s+/gu, ' ').trim()
+        : '', 256, '…');
+}
+function normalizeItem(value) {
+    if (!isRecord(value)) {
+        return Object.freeze({
+            isText: false,
+            text: '',
+            rendered: '[iLink item: unknown type; content not parsed]',
+        });
+    }
+    const type = Number.isSafeInteger(value.type) && Number(value.type) >= 0
+        ? Number(value.type)
+        : undefined;
+    if (type === IlinkMessageItemType.TEXT) {
+        const textItem = isRecord(value.text_item) ? value.text_item : {};
+        const rawText = typeof textItem.text === 'string' ? textItem.text : '';
+        const text = truncateUtf8(rawText, MAX_TEXT_BYTES, '…');
+        return Object.freeze({
+            type,
+            isText: true,
+            text,
+            rendered: text.trim() ? text : '[iLink text: empty]',
+        });
+    }
+    let rendered;
+    switch (type) {
+        case IlinkMessageItemType.IMAGE:
+            rendered = '[iLink image: not downloaded or viewed]';
+            break;
+        case IlinkMessageItemType.VOICE:
+            rendered = '[iLink voice: not downloaded, played, or transcribed]';
+            break;
+        case IlinkMessageItemType.FILE: {
+            const file = isRecord(value.file_item) ? value.file_item : {};
+            const filename = safeFilename(file.file_name);
+            rendered = filename
+                ? `[iLink file: ${filename}; not downloaded or opened]`
+                : '[iLink file: not downloaded or opened]';
+            break;
+        }
+        case IlinkMessageItemType.VIDEO:
+            rendered = '[iLink video: not downloaded, watched, or transcribed]';
+            break;
+        default:
+            rendered = type === undefined
+                ? '[iLink item: unknown type; content not parsed]'
+                : `[iLink non-text item (type ${type}): content not parsed]`;
+    }
+    return Object.freeze({
+        ...(type === undefined ? {} : { type }),
+        isText: false,
+        text: '',
+        rendered,
+    });
+}
+function validOptionalSafeInteger(value) {
+    return value === undefined ||
+        (Number.isSafeInteger(value) && Number(value) >= 0);
+}
+/**
+ * Returns null for messages outside the active one-to-one pair or for malformed
+ * provider envelopes. Provider reply and media secrets remain isolated in facts
+ * so the host can seal them before persistence.
+ */
+export function normalizeIlinkInboundMessage(message, activePair, syncPosition) {
+    const pair = normalizePair(activePair);
+    const sync = normalizeSync(syncPosition);
+    if (!isRecord(message))
+        return null;
+    const inbound = message;
+    const contextToken = inbound.context_token;
+    const createTime = inbound.create_time_ms;
+    const seq = inbound.seq;
+    if (inbound.from_user_id !== pair.ownerUserId ||
+        inbound.to_user_id !== pair.botId ||
+        inbound.message_type !== IlinkMessageType.USER ||
+        inbound.message_state !== IlinkMessageState.FINISH ||
+        typeof contextToken !== 'string' ||
+        !contextToken ||
+        contextToken.length > MAX_CONTEXT_TOKEN_CHARACTERS ||
+        contextToken.includes('\0') ||
+        typeof createTime !== 'number' ||
+        !Number.isSafeInteger(createTime) ||
+        createTime < 0 ||
+        !validOptionalSafeInteger(seq) ||
+        (inbound.item_list !== undefined && !Array.isArray(inbound.item_list)) ||
+        (inbound.item_list?.length ?? 0) > MAX_ITEMS) {
+        return null;
+    }
+    const items = (inbound.item_list ?? []).map(normalizeItem);
+    const textItems = items.filter((item) => item.isText);
+    const nonTextCount = items.length - textItems.length;
+    const text = truncateUtf8(textItems.map((item) => item.text).join('\n'), MAX_TEXT_BYTES, '…');
+    const summary = truncateUtf8(items.length > 0
+        ? items.map((item) => item.rendered).join('\n')
+        : '[iLink message: no readable content]', MAX_SUMMARY_BYTES, '…');
+    const kind = textItems.length > 0
+        ? nonTextCount > 0 ? 'mixed' : 'text'
+        : nonTextCount > 0 ? 'non_text' : 'empty';
+    const stableProviderMessageId = providerMessageId(inbound);
+    if (!stableProviderMessageId)
+        return null;
+    const images = (inbound.item_list ?? []).flatMap((value, position) => {
+        if (!isRecord(value) || value.type !== IlinkMessageItemType.IMAGE)
+            return [];
+        try {
+            const locator = extractIlinkInboundImageLocator(value.image_item);
+            const aesKey = locator.aesKey.toString('base64url');
+            locator.aesKey.fill(0);
+            return [{ position, downloadUrl: locator.downloadUrl, aesKey }];
+        }
+        catch {
+            return [];
+        }
+    }).slice(-MAX_NATIVE_IMAGES);
+    const imageFacts = Object.freeze(images.map((image) => Object.freeze(image)));
+    const itemTypes = Object.freeze(items.flatMap((item) => item.type === undefined ? [] : [item.type]));
+    const normalizedMessage = Object.freeze({
+        providerMessageId: stableProviderMessageId,
+        origin: MESSAGE_ORIGINS.CUSTOMER,
+        type: kind,
+        rawType: `ilink_${kind}`,
+        sentAt: createTime,
+        sync,
+        conversation: Object.freeze({
+            channel: ILINK_CHANNEL,
+            accountKey: pair.accountKey,
+            peerId: pair.ownerUserId,
+        }),
+        text,
+        summary,
+        attributes: Object.freeze({
+            itemTypes,
+        }),
+        attachments: Object.freeze(imageFacts.map((image) => Object.freeze({
+            kind: 'image',
+            mediaId: `ilink:${image.position}`,
+            filename: `ilink-image-${image.position}`,
+            status: 'unresolved',
+        }))),
+    });
+    return Object.freeze({
+        message: normalizedMessage,
+        facts: Object.freeze({
+            contextToken,
+            ...(seq === undefined ? {} : { providerSeq: seq }),
+            images: imageFacts,
+        }),
+    });
+}