@kin-tio/cli 0.6.0

package/dist/src/domain/wecom-message.js

@@ -0,0 +1,281 @@
+import { createHash } from 'node:crypto';
+import { truncateUtf8 } from '../lib/text.js';
+import { COMMON_MESSAGE_TYPES, MESSAGE_ORIGINS, } from './message.js';
+export const MESSAGE_TYPES = {
+    TEXT: COMMON_MESSAGE_TYPES.TEXT,
+    IMAGE: 'image',
+    VOICE: 'voice',
+    VIDEO: 'video',
+    FILE: 'file',
+    LOCATION: 'location',
+    LINK: 'link',
+    BUSINESS_CARD: 'business_card',
+    MINIPROGRAM: 'miniprogram',
+    MSGMENU: 'msgmenu',
+    CHANNELS_SHOP_PRODUCT: 'channels_shop_product',
+    CHANNELS_SHOP_ORDER: 'channels_shop_order',
+    MERGED_MESSAGE: 'merged_msg',
+    CHANNELS: 'channels',
+    NOTE: 'note',
+    EVENT: COMMON_MESSAGE_TYPES.EVENT,
+    UNKNOWN: COMMON_MESSAGE_TYPES.UNKNOWN,
+};
+function canonicalValue(value) {
+    if (Array.isArray(value))
+        return value.map(canonicalValue);
+    if (!value || typeof value !== 'object')
+        return value;
+    const source = value;
+    return Object.fromEntries(Object.keys(source).sort().flatMap((key) => source[key] === undefined ? [] : [[key, canonicalValue(source[key])]]));
+}
+function stableEventProviderId(accountKey, cursor, index, message) {
+    // Preserve the v21 fallback identity so an old no-msgid event replay remains
+    // a duplicate after the Provider ID moves out of the persistence layer.
+    const legacyPayload = { id: '', ...message };
+    const digest = createHash('sha256').update(`${accountKey}\0${cursor}\0${index}\0${JSON.stringify(canonicalValue(legacyPayload))}`).digest('hex');
+    return `event_${digest.slice(0, 40)}`;
+}
+const KNOWN_TYPES = new Set(Object.values(MESSAGE_TYPES));
+const MAX_MERGED_ITEMS = 50;
+const MAX_MERGED_DEPTH = 3;
+const MAX_SUMMARY_BYTES = 16 * 1024;
+function asObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function clean(value, maxBytes = 1024) {
+    return truncateUtf8(String(value ?? '')
+        .replace(/\s+/gu, ' ')
+        .trim(), maxBytes, '…');
+}
+function numberLabel(label, value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? `${label}${parsed}` : '';
+}
+function labeled(label, values) {
+    const detail = values.filter(Boolean).join('; ');
+    return detail ? `[WeChat ${label}] ${detail}` : `[WeChat ${label}]`;
+}
+function menuOptions(menu) {
+    const list = menu?.list;
+    if (!Array.isArray(list))
+        return '';
+    return list
+        .slice(0, 20)
+        .map((item) => {
+        const row = asObject(item);
+        const type = clean(row.type || 'unknown', 64);
+        const body = asObject(row[type]);
+        return clean(body.content || `[${type}]`, 256);
+    })
+        .filter(Boolean)
+        .join(', ');
+}
+function parseMergedItems(items, depth) {
+    if (!Array.isArray(items))
+        return [];
+    return items.slice(0, MAX_MERGED_ITEMS).map((value) => {
+        const item = asObject(value);
+        let payload;
+        try {
+            payload = JSON.parse(String(item.msg_content || '{}'));
+            if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+                payload = null;
+            }
+            else if (!payload.msgtype && item.msgtype) {
+                payload = { ...payload, msgtype: item.msgtype };
+            }
+        }
+        catch {
+            payload = null;
+        }
+        return Object.freeze({
+            sendTime: Number(item.send_time || 0),
+            type: String(item.msgtype || payload?.msgtype || 'unknown'),
+            senderName: clean(item.sender_name || 'Unknown sender', 256),
+            summary: summarizePayload(payload, depth),
+        });
+    });
+}
+function mergedSummary(mergedValue, depth) {
+    const merged = asObject(mergedValue);
+    if (depth >= MAX_MERGED_DEPTH) {
+        return '[WeChat chat history: nesting limit reached]';
+    }
+    const title = clean(merged?.title, 256);
+    const items = parseMergedItems(merged?.item, depth + 1);
+    const lines = [
+        `[WeChat chat history${title ? `: ${title}` : ''}]`,
+        ...items.map((item, index) => `${index + 1}. ${item.senderName}: ${item.summary}`),
+    ];
+    return truncateUtf8(lines.join('\n'), MAX_SUMMARY_BYTES, '…');
+}
+function summarizePayload(payload, depth = 0) {
+    if (!payload || typeof payload !== 'object')
+        return '[WeChat message: unreadable payload]';
+    const type = String(payload.msgtype || 'unknown');
+    switch (type) {
+        case MESSAGE_TYPES.TEXT: {
+            const content = clean(payload.text?.content, MAX_SUMMARY_BYTES);
+            const menuId = clean(payload.text?.menu_id, 128);
+            return menuId
+                ? `The participant selected a menu item: ${content || '[empty text]'} (menu_id: ${menuId})`
+                : content || '[WeChat text: empty]';
+        }
+        case MESSAGE_TYPES.IMAGE:
+            return '[WeChat image: attached as native image input]';
+        case MESSAGE_TYPES.VOICE:
+            return '[WeChat voice: not downloaded or transcribed]';
+        case MESSAGE_TYPES.VIDEO:
+            return '[WeChat video: not downloaded, watched, or transcribed]';
+        case MESSAGE_TYPES.FILE:
+            return labeled('file', [
+                clean(payload.file?.filename, 256),
+                payload.file?.file_size
+                    ? `size ${clean(payload.file.file_size, 64)}`
+                    : '',
+                'content not downloaded or opened',
+            ]);
+        case MESSAGE_TYPES.LOCATION:
+            return labeled('location', [
+                clean(payload.location?.name, 256),
+                clean(payload.location?.address, 512),
+                numberLabel('latitude ', payload.location?.latitude),
+                numberLabel('longitude ', payload.location?.longitude),
+            ]);
+        case MESSAGE_TYPES.LINK:
+            return labeled('link', [
+                clean(payload.link?.title, 256),
+                clean(payload.link?.desc, 512),
+                clean(payload.link?.url, 2048),
+            ]);
+        case MESSAGE_TYPES.BUSINESS_CARD:
+            return '[WeChat business card: contact details not parsed]';
+        case MESSAGE_TYPES.MINIPROGRAM:
+            return labeled('mini program', [
+                clean(payload.miniprogram?.title, 256),
+                clean(payload.miniprogram?.appid, 128),
+                clean(payload.miniprogram?.pagepath, 1024),
+            ]);
+        case MESSAGE_TYPES.MSGMENU:
+            return labeled('menu', [
+                clean(payload.msgmenu?.head_content, 512),
+                menuOptions(payload.msgmenu),
+                clean(payload.msgmenu?.tail_content, 512),
+            ]);
+        case MESSAGE_TYPES.CHANNELS_SHOP_PRODUCT:
+            return labeled('Channels product', [
+                clean(payload.channels_shop_product?.title, 256),
+                payload.channels_shop_product?.sales_price
+                    ? `price (cents) ${clean(payload.channels_shop_product.sales_price, 64)}`
+                    : '',
+                clean(payload.channels_shop_product?.shop_nickname, 256),
+                payload.channels_shop_product?.product_id
+                    ? `product ID ${clean(payload.channels_shop_product.product_id, 128)}`
+                    : '',
+            ]);
+        case MESSAGE_TYPES.CHANNELS_SHOP_ORDER:
+            return labeled('Channels order', [
+                payload.channels_shop_order?.order_id
+                    ? `order ID ${clean(payload.channels_shop_order.order_id, 128)}`
+                    : '',
+                clean(payload.channels_shop_order?.product_titles, 512),
+                clean(payload.channels_shop_order?.price_wording, 128),
+                clean(payload.channels_shop_order?.state, 128),
+                clean(payload.channels_shop_order?.shop_nickname, 256),
+            ]);
+        case MESSAGE_TYPES.MERGED_MESSAGE:
+            return mergedSummary(payload.merged_msg, depth);
+        case MESSAGE_TYPES.CHANNELS:
+            return labeled('Channels content', [
+                clean(payload.channels?.nickname, 256),
+                clean(payload.channels?.title, 512),
+                payload.channels?.sub_type
+                    ? `type ${clean(payload.channels.sub_type, 64)}`
+                    : '',
+            ]);
+        case MESSAGE_TYPES.NOTE:
+            return '[WeChat note: API returned no readable body]';
+        default:
+            return `[WeChat ${clean(type, 128) || 'unknown'} message: content not parsed]`;
+    }
+}
+function messageAttributes(type, raw) {
+    switch (type) {
+        case MESSAGE_TYPES.TEXT:
+            return { menuId: String(raw.text?.menu_id || '') };
+        case MESSAGE_TYPES.LOCATION:
+            return {
+                latitude: Number(raw.location?.latitude),
+                longitude: Number(raw.location?.longitude),
+                name: String(raw.location?.name || ''),
+                address: String(raw.location?.address || ''),
+            };
+        case MESSAGE_TYPES.LINK:
+            return {
+                title: String(raw.link?.title || ''),
+                description: String(raw.link?.desc || ''),
+                url: String(raw.link?.url || ''),
+            };
+        case MESSAGE_TYPES.MINIPROGRAM:
+            return {
+                title: String(raw.miniprogram?.title || ''),
+                appId: String(raw.miniprogram?.appid || ''),
+                pagePath: String(raw.miniprogram?.pagepath || ''),
+            };
+        case MESSAGE_TYPES.MERGED_MESSAGE:
+            return {
+                title: String(raw.merged_msg?.title || ''),
+                items: parseMergedItems(raw.merged_msg?.item, 1),
+            };
+        case MESSAGE_TYPES.EVENT:
+            return structuredClone(raw.event || {});
+        default:
+            return {};
+    }
+}
+export function normalizeWecomMessage(rawMessage, fallbackOpenKfId = '', { cursor = '', index = 0 } = {}) {
+    const raw = asObject(rawMessage);
+    const rawType = String(raw.msgtype || 'unknown');
+    const type = KNOWN_TYPES.has(rawType)
+        ? rawType
+        : MESSAGE_TYPES.UNKNOWN;
+    const event = asObject(raw.event);
+    const origin = Number(raw.origin);
+    const mediaId = type === MESSAGE_TYPES.IMAGE ? String(raw.image?.media_id || '') : '';
+    const text = type === MESSAGE_TYPES.TEXT ? String(raw.text?.content || '') : '';
+    const sync = Object.freeze({
+        cursor: String(cursor || ''),
+        index: Number.isInteger(index) && index >= 0 ? index : 0,
+    });
+    const conversation = Object.freeze({
+        channel: 'wechat_kf',
+        accountKey: String(raw.open_kfid || event.open_kfid || fallbackOpenKfId),
+        peerId: String(raw.external_userid || event.external_userid || ''),
+    });
+    const normalized = {
+        origin: origin === 3
+            ? MESSAGE_ORIGINS.CUSTOMER
+            : origin === 4
+                ? MESSAGE_ORIGINS.SYSTEM
+                : MESSAGE_ORIGINS.UNKNOWN,
+        type,
+        rawType,
+        sentAt: Number(raw.send_time || 0),
+        sync,
+        conversation,
+        text,
+        summary: type === MESSAGE_TYPES.EVENT
+            ? `[WeChat system event: ${clean(event.event_type || 'unknown', 128)}]`
+            : summarizePayload({ ...raw, msgtype: type }),
+        attributes: Object.freeze(messageAttributes(type, raw)),
+        attachments: Object.freeze(mediaId
+            ? [Object.freeze({ kind: 'image', mediaId, status: 'unresolved' })]
+            : []),
+    };
+    return Object.freeze({
+        providerMessageId: String(raw.msgid || '') || stableEventProviderId(conversation.accountKey, sync.cursor, sync.index, normalized),
+        ...normalized,
+    });
+}

package/dist/src/ilink/executor.js

@@ -0,0 +1,306 @@
+import { randomBytes } from 'node:crypto';
+import { IlinkClient, IlinkProtocolError, } from './protocol/client.js';
+import { IlinkMessageItemType, IlinkMessageState, IlinkMessageType, } from './protocol/types.js';
+import { IlinkSecretBox } from './secret-box.js';
+import { IlinkMediaError, uploadIlinkImageBuffer, } from './media.js';
+import { IlinkSqliteStore, IlinkSqliteStoreError, } from './sqlite-store.js';
+function receipt(attempt, error) {
+    return {
+        status: attempt.status === 'failed'
+            ? 'failed'
+            : attempt.status === 'uncertain' ? 'uncertain' : 'accepted',
+        attemptId: attempt.attemptId,
+        sendIndex: attempt.sendIndex,
+        type: attempt.type === 'image' ? 'image' : 'text',
+        providerMessageId: attempt.providerMessageId,
+        ...(error ? { error } : {}),
+    };
+}
+function preflightError(error, forcedKind) {
+    const code = error instanceof IlinkSqliteStoreError ? error.code : '';
+    const kind = forcedKind || (code === 'reply_window_expired'
+        ? 'reply_window_expired'
+        : code === 'reply_quota_exhausted'
+            ? 'reply_quota_exhausted'
+            : 'ilink_session_invalid');
+    return { kind, message: 'iLink send precondition failed' };
+}
+function preflightFailure(error, type = 'text', forcedKind) {
+    return {
+        status: 'failed',
+        attemptId: '',
+        sendIndex: -1,
+        type,
+        providerMessageId: '',
+        error: preflightError(error, forcedKind),
+    };
+}
+function definitive(error) {
+    return error instanceof IlinkProtocolError && (error.kind === 'business' ||
+        (error.kind === 'http' && Number(error.status || 0) >= 400 &&
+            Number(error.status || 0) < 500));
+}
+function deliveryError(error, uncertain) {
+    const protocol = error instanceof IlinkProtocolError ? error : undefined;
+    return {
+        kind: uncertain ? 'uncertain_result' : 'ilink_delivery_failed',
+        message: uncertain
+            ? 'The iLink delivery outcome is uncertain'
+            : 'iLink rejected the message',
+        ...(protocol?.ret !== undefined ? { ret: protocol.ret } : {}),
+        ...(protocol?.status !== undefined ? { code: protocol.status } : {}),
+    };
+}
+export class IlinkSendExecutor {
+    #store;
+    #ilink;
+    #secrets;
+    #createClient;
+    #media;
+    #uploadImage;
+    #queues = new Map();
+    constructor({ store, ilinkStore, secretBox, createClient = ({ token, baseUrl }) => new IlinkClient({ token, baseUrl }), mediaGateway, uploadImage = uploadIlinkImageBuffer, }) {
+        this.#store = store;
+        this.#ilink = ilinkStore;
+        this.#secrets = secretBox;
+        this.#createClient = createClient;
+        this.#media = mediaGateway;
+        this.#uploadImage = uploadImage;
+    }
+    #serialize(accountKey, operation) {
+        const previous = this.#queues.get(accountKey) || Promise.resolve();
+        const task = previous.catch(() => undefined).then(operation);
+        this.#queues.set(accountKey, task);
+        void task.finally(() => {
+            if (this.#queues.get(accountKey) === task)
+                this.#queues.delete(accountKey);
+        }).catch(() => undefined);
+        return task;
+    }
+    #releasePending(attemptId, error, type, forcedKind) {
+        this.#ilink.releasePendingAttempt(attemptId, error instanceof IlinkSqliteStoreError &&
+            error.code === 'reply_window_expired'
+            ? 'reply_window_expired'
+            : undefined);
+        const failed = this.#store.getAttempt(attemptId);
+        return failed
+            ? receipt(failed, preflightError(error, forcedKind))
+            : preflightFailure(error, type, forcedKind);
+    }
+    async execute(tool, input) {
+        if (tool !== 'send_text' && tool !== 'send_image') {
+            return preflightFailure(new Error('unsupported tool'));
+        }
+        let accountKey;
+        try {
+            const session = this.#store.getAgentSession(input.session);
+            if (session.channel !== 'weixin_ilink') {
+                return preflightFailure(new Error('wrong channel'));
+            }
+            accountKey = session.accountKey;
+        }
+        catch (error) {
+            return preflightFailure(error);
+        }
+        return this.#serialize(accountKey, () => tool === 'send_image' ? this.#executeImage(input) : this.#executeText(input));
+    }
+    async #executeText(input) {
+        let pendingAttemptId = '';
+        try {
+            if (typeof input.content !== 'string' || !input.content) {
+                return preflightFailure(new Error('missing text'));
+            }
+            const session = this.#store.getAgentSession(input.session);
+            if (session.channel !== 'weixin_ilink' || !session.replyWindowId) {
+                return preflightFailure(new Error('wrong channel'));
+            }
+            const clientId = `il_${randomBytes(16).toString('base64url')}`;
+            const prepared = this.#ilink.prepareReplyAttempt({
+                sessionToken: input.session,
+                sentType: 'text',
+                payload: { content: input.content, clientId },
+                metadata: { tool: 'send_text' },
+            });
+            if (prepared.kind === 'rejected') {
+                return receipt(prepared.attempt, preflightError(undefined, prepared.code));
+            }
+            pendingAttemptId = prepared.attempt.attemptId;
+            const delivery = this.#deliveryContext(session.replyWindowId);
+            const attempt = this.#ilink.startReplyAttempt({
+                sessionToken: input.session,
+                attemptId: pendingAttemptId,
+            });
+            return this.#transmit(attempt, delivery, {
+                type: IlinkMessageItemType.TEXT,
+                text_item: { text: input.content },
+            }, clientId);
+        }
+        catch (error) {
+            return pendingAttemptId
+                ? this.#releasePending(pendingAttemptId, error, 'text')
+                : preflightFailure(error);
+        }
+    }
+    async #executeImage(input) {
+        let pendingAttemptId = '';
+        try {
+            const session = this.#store.getAgentSession(input.session);
+            if (session.channel !== 'weixin_ilink' || !session.replyWindowId ||
+                typeof input.mediaRef !== 'string') {
+                return preflightFailure(new Error('invalid image session'), 'image');
+            }
+            let artifact;
+            if (input.mediaRef.startsWith('artifact:')) {
+                try {
+                    artifact = this.#store.getAgentArtifact(input.session, input.mediaRef);
+                }
+                catch (error) {
+                    return preflightFailure(error, 'image', 'invalid_media_reference');
+                }
+            }
+            const clientId = `il_${randomBytes(16).toString('base64url')}`;
+            const prepared = this.#ilink.prepareReplyAttempt({
+                sessionToken: input.session,
+                sentType: 'image',
+                payload: { mediaRef: input.mediaRef, clientId },
+                metadata: artifact
+                    ? { ...(artifact.metadata || {}), tool: 'generated_image' }
+                    : { tool: 'send_image' },
+            });
+            if (prepared.kind === 'rejected') {
+                return receipt(prepared.attempt, preflightError(undefined, prepared.code));
+            }
+            pendingAttemptId = prepared.attempt.attemptId;
+            const delivery = this.#deliveryContext(session.replyWindowId);
+            let bytes;
+            try {
+                if (artifact) {
+                    bytes = artifact.bytes;
+                }
+                else {
+                    const source = session.mediaCatalog.find((item) => item.ref === input.mediaRef);
+                    if (!source || !this.#media) {
+                        return this.#releasePending(pendingAttemptId, new Error('image reference unavailable'), 'image', 'invalid_media_reference');
+                    }
+                    bytes = (await this.#media.resolveReference({
+                        messageKey: source.messageKey,
+                        mediaId: source.mediaId,
+                    })).bytes;
+                }
+            }
+            catch (error) {
+                return this.#releasePending(pendingAttemptId, error, 'image', input.mediaRef.startsWith('artifact:')
+                    ? 'invalid_media_reference'
+                    : 'media_prepare_failed');
+            }
+            let imageItem;
+            try {
+                this.#ilink.validatePendingReplyAttempt({
+                    sessionToken: input.session,
+                    attemptId: pendingAttemptId,
+                });
+                imageItem = await this.#uploadImage({
+                    bytes,
+                    peerId: delivery.peerId,
+                    client: delivery.client,
+                });
+                this.#store.getAgentSession(input.session);
+                const attempt = this.#ilink.startReplyAttempt({
+                    sessionToken: input.session,
+                    attemptId: pendingAttemptId,
+                });
+                return this.#transmit(attempt, delivery, imageItem, clientId);
+            }
+            catch (error) {
+                return this.#releasePending(pendingAttemptId, error, 'image', error instanceof IlinkMediaError ? 'media_prepare_failed' : undefined);
+            }
+        }
+        catch (error) {
+            return pendingAttemptId
+                ? this.#releasePending(pendingAttemptId, error, 'image')
+                : preflightFailure(error, 'image');
+        }
+    }
+    #deliveryContext(replyWindowId) {
+        const window = this.#ilink.getReplyWindowSecret(replyWindowId);
+        const accountWithSecret = window
+            ? this.#ilink.getAccountWithSecret(window.accountKey)
+            : undefined;
+        if (!accountWithSecret || !window ||
+            window.peerId !== accountWithSecret.account.ownerPeerId) {
+            throw new Error('Missing bound iLink delivery state');
+        }
+        const botToken = this.#secrets.open(accountWithSecret.secret.sealedBotToken, {
+            secretKind: 'bot_token',
+            accountId: accountWithSecret.account.accountKey,
+            peerId: accountWithSecret.account.ownerPeerId,
+            generation: accountWithSecret.account.generation,
+        });
+        const contextToken = this.#secrets.open(window.sealedContextToken, {
+            secretKind: 'context_token',
+            accountId: window.accountKey,
+            peerId: window.peerId,
+            generation: window.secretGeneration,
+        });
+        return {
+            client: this.#createClient({
+                token: botToken,
+                baseUrl: accountWithSecret.account.baseUrl,
+            }),
+            contextToken,
+            peerId: window.peerId,
+        };
+    }
+    async #transmit(attempt, delivery, item, clientId) {
+        try {
+            await delivery.client.sendMessage({
+                msg: {
+                    from_user_id: '',
+                    to_user_id: delivery.peerId,
+                    client_id: clientId,
+                    message_type: IlinkMessageType.BOT,
+                    message_state: IlinkMessageState.FINISH,
+                    context_token: delivery.contextToken,
+                    item_list: [item],
+                },
+            });
+        }
+        catch (error) {
+            if (definitive(error)) {
+                const failed = this.#store.failSend(attempt.attemptId, error);
+                return receipt(failed, deliveryError(error, false));
+            }
+            const uncertain = this.#store.markSendUncertain(attempt.attemptId, error);
+            return receipt(uncertain, deliveryError(error, true));
+        }
+        const accepted = this.#store.completeSend(attempt.attemptId, {
+            providerMessageId: clientId,
+        });
+        return receipt(accepted);
+    }
+    async notifyQueued(messageKey, content = 'Your conversation is queued. Please wait.') {
+        const window = this.#ilink.getReplyWindowSecretBySource(messageKey);
+        if (!window)
+            throw new Error('iLink queue notice has no reply window');
+        await this.#serialize(window.accountKey, async () => {
+            const delivery = this.#deliveryContext(window.replyWindowId);
+            const clientId = `il_${randomBytes(16).toString('base64url')}`;
+            const attempt = this.#ilink.reserveStartedSystemAttempt({
+                messageKey,
+                sentType: 'text',
+                source: 'queue_notice',
+                payload: { content, clientId },
+                metadata: { tool: 'queue_notice' },
+            });
+            const result = await this.#transmit(attempt, delivery, {
+                type: IlinkMessageItemType.TEXT,
+                text_item: { text: content },
+            }, clientId);
+            if (result.status === 'failed')
+                throw new Error('iLink queue notice failed');
+        });
+    }
+    async waitForIdle() {
+        await Promise.allSettled([...this.#queues.values()]);
+    }
+}