@kin-tio/cli 0.6.0

package/dist/src/services/image-stager.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs/promises';
+import { readdirSync, rmSync, } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { MAX_WECHAT_IMAGE_BYTES, detectImageFormat, } from '../lib/image-format.js';
+import { ensurePrivateDirectory } from '../lib/private-directory.js';
+const STAGED_IMAGE_PREFIX = 'kintio-image-';
+const LEGACY_STAGED_IMAGE_PREFIXES = [
+    'talkferry-image-',
+    'wechat-codex-image-',
+];
+export function cleanupStagedImageOrphans(temporaryRoot) {
+    ensurePrivateDirectory(temporaryRoot);
+    for (const entry of readdirSync(temporaryRoot, { withFileTypes: true })) {
+        if (!entry.name.startsWith(STAGED_IMAGE_PREFIX) &&
+            !LEGACY_STAGED_IMAGE_PREFIXES.some((prefix) => entry.name.startsWith(prefix)))
+            continue;
+        rmSync(path.join(temporaryRoot, entry.name), { recursive: true, force: true });
+    }
+}
+export async function withStagedImages(images, { temporaryRoot = os.tmpdir() } = {}, operation) {
+    if (images.length === 0) {
+        return operation([]);
+    }
+    const temporaryDirectory = await fs.mkdtemp(path.join(temporaryRoot, STAGED_IMAGE_PREFIX));
+    await fs.chmod(temporaryDirectory, 0o700);
+    try {
+        const paths = [];
+        for (const [index, image] of images.entries()) {
+            if (!Buffer.isBuffer(image.bytes) || image.bytes.length === 0) {
+                throw new Error('Downloaded image is empty');
+            }
+            if (image.bytes.length > MAX_WECHAT_IMAGE_BYTES) {
+                throw new Error('Downloaded image exceeds the 2 MiB WeChat limit');
+            }
+            const format = detectImageFormat(image.bytes);
+            if (!format) {
+                throw new Error('Downloaded media is not a supported image format');
+            }
+            const imagePath = path.join(temporaryDirectory, `image-${index}${format.extension}`);
+            await fs.writeFile(imagePath, image.bytes, { mode: 0o600 });
+            paths.push(imagePath);
+        }
+        return await operation(paths);
+    }
+    finally {
+        await fs.rm(temporaryDirectory, { recursive: true, force: true });
+    }
+}

package/dist/src/services/media-gateway.js

@@ -0,0 +1,83 @@
+const DEFAULT_LINK_THUMBNAIL = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Y9ZlXcAAAAASUVORK5CYII=', 'base64');
+const LINK_THUMBNAIL_CACHE_MS = 60 * 60 * 1000;
+const OUTBOUND_MEDIA_CACHE_MS = 60 * 60 * 1000;
+const IMAGE_KIND = 'image';
+function defaultFilename(kind, contentType) {
+    if (kind === IMAGE_KIND) {
+        return contentType === 'image/jpeg' ? 'image.jpg' : 'image.png';
+    }
+    throw new Error(`Unsupported outbound attachment kind: ${kind}`);
+}
+export class WecomMediaGateway {
+    apiClient;
+    cardThumbnailCache;
+    outboundMediaCache;
+    constructor({ apiClient }) {
+        this.apiClient = apiClient;
+        this.cardThumbnailCache = null;
+        this.outboundMediaCache = new Map();
+    }
+    async resolveForCodex(message) {
+        const resolved = [];
+        for (const attachment of message.attachments || []) {
+            if (attachment.kind !== IMAGE_KIND)
+                continue;
+            const media = await this.apiClient.downloadMedia(attachment.mediaId);
+            resolved.push({
+                kind: IMAGE_KIND,
+                bytes: media.bytes,
+                contentType: media.contentType,
+            });
+        }
+        return resolved;
+    }
+    async upload({ kind, bytes, filename, contentType, }) {
+        if (kind !== IMAGE_KIND) {
+            throw new Error(`Unsupported attachment kind: ${kind}`);
+        }
+        return this.apiClient.uploadMedia({
+            type: 'image',
+            bytes,
+            filename,
+            contentType,
+        });
+    }
+    async cloneForSend({ kind, sourceMediaId, filename = '', }) {
+        const cacheKey = `${kind}:${sourceMediaId}`;
+        const cached = this.outboundMediaCache.get(cacheKey);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.mediaId;
+        }
+        const source = await this.apiClient.downloadMedia(sourceMediaId);
+        const uploaded = await this.upload({
+            kind,
+            bytes: source.bytes,
+            filename: filename ||
+                source.filename ||
+                defaultFilename(kind, source.contentType),
+            contentType: source.contentType,
+        });
+        this.outboundMediaCache.set(cacheKey, {
+            mediaId: uploaded.media_id,
+            expiresAt: Date.now() + OUTBOUND_MEDIA_CACHE_MS,
+        });
+        return uploaded.media_id;
+    }
+    async getCardThumbnailMediaId() {
+        const cached = this.cardThumbnailCache;
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.mediaId;
+        }
+        const result = await this.upload({
+            kind: IMAGE_KIND,
+            bytes: DEFAULT_LINK_THUMBNAIL,
+            filename: 'link-thumbnail.png',
+            contentType: 'image/png',
+        });
+        this.cardThumbnailCache = {
+            mediaId: result.media_id,
+            expiresAt: Date.now() + LINK_THUMBNAIL_CACHE_MS,
+        };
+        return this.cardThumbnailCache.mediaId;
+    }
+}

package/dist/src/services/wecom-api.js

@@ -0,0 +1,311 @@
+import crypto from 'node:crypto';
+const DEFAULT_BASE_URL = 'https://qyapi.weixin.qq.com';
+const INVALID_ACCESS_TOKEN_CODES = new Set([40014, 42001]);
+const MAX_MEDIA_ID_CHARACTERS = 512;
+const MAX_DOWNLOAD_BYTES = 2 * 1024 * 1024;
+const MEDIA_LIMITS = Object.freeze({
+    image: 2 * 1024 * 1024,
+});
+const SEND_MESSAGE_TYPES = new Set([
+    'text',
+    'image',
+    'link',
+    'miniprogram',
+    'location',
+]);
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function withClientMessageId(body, messageId) {
+    const value = String(messageId || '');
+    if (!value)
+        return body;
+    if (value.length > 32 || !/^[0-9A-Za-z_-]+$/.test(value)) {
+        throw new Error('WeCom client messageId must use 1 to 32 letters, digits, underscores, or hyphens');
+    }
+    return { ...body, msgid: value };
+}
+function safeFilename(filename) {
+    return String(filename || 'media.bin')
+        .replace(/[\r\n"\\/]/g, '_')
+        .slice(0, 128);
+}
+function responseFilename(contentDisposition) {
+    const value = String(contentDisposition || '');
+    const encoded = value.match(/filename\*\s*=\s*UTF-8''([^;]+)/i)?.[1];
+    if (encoded) {
+        try {
+            return safeFilename(decodeURIComponent(encoded));
+        }
+        catch {
+            return safeFilename(encoded);
+        }
+    }
+    const plain = value.match(/filename\s*=\s*"([^"]+)"/i)?.[1];
+    return plain ? safeFilename(plain) : '';
+}
+function createMultipartBody({ bytes, filename, contentType, }) {
+    const boundary = `----kintio-${crypto.randomUUID()}`;
+    const header = Buffer.from([
+        `--${boundary}`,
+        `Content-Disposition: form-data; name="media"; filename="${safeFilename(filename)}"; filelength=${bytes.length}`,
+        `Content-Type: ${contentType || 'application/octet-stream'}`,
+        '',
+        '',
+    ].join('\r\n'));
+    const footer = Buffer.from(`\r\n--${boundary}--\r\n`);
+    return {
+        body: Buffer.concat([header, bytes, footer]),
+        contentType: `multipart/form-data; boundary=${boundary}`,
+    };
+}
+async function readLimitedBody(response, limit = MAX_DOWNLOAD_BYTES) {
+    const declaredLength = Number(response.headers.get('content-length') || 0);
+    if (declaredLength > limit) {
+        throw new WecomApiError(`media/get response exceeds ${limit} bytes`);
+    }
+    if (!response.body?.getReader) {
+        const bytes = Buffer.from(await response.arrayBuffer());
+        if (bytes.length > limit) {
+            throw new WecomApiError(`media/get response exceeds ${limit} bytes`);
+        }
+        return bytes;
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > limit) {
+                await reader.cancel();
+                throw new WecomApiError(`media/get response exceeds ${limit} bytes`);
+            }
+            chunks.push(Buffer.from(value));
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks, size);
+}
+export class WecomApiError extends Error {
+    code;
+    data;
+    constructor(message, { code, data } = {}) {
+        super(message);
+        this.name = 'WecomApiError';
+        this.code = code;
+        this.data = data;
+    }
+}
+export class WecomApiClient {
+    corpId;
+    kfSecret;
+    fetch;
+    baseUrl;
+    timeoutMs;
+    tokenCache = null;
+    pendingTokenRequest = null;
+    constructor({ corpId, kfSecret, fetchImpl = globalThis.fetch, baseUrl = DEFAULT_BASE_URL, timeoutMs = 10_000, }) {
+        if (!corpId || !kfSecret) {
+            throw new Error('WeCom CorpID and WeChat KF Secret are required');
+        }
+        if (typeof fetchImpl !== 'function') {
+            throw new Error('A fetch implementation is required');
+        }
+        this.corpId = corpId;
+        this.kfSecret = kfSecret;
+        this.fetch = fetchImpl;
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.timeoutMs = timeoutMs;
+    }
+    clearAccessToken() {
+        this.tokenCache = null;
+    }
+    async getAccessToken() {
+        const cached = this.tokenCache;
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.value;
+        }
+        if (this.pendingTokenRequest) {
+            return this.pendingTokenRequest;
+        }
+        this.pendingTokenRequest = this.#requestAccessToken().finally(() => {
+            this.pendingTokenRequest = null;
+        });
+        return this.pendingTokenRequest;
+    }
+    async #requestAccessToken() {
+        const query = new URLSearchParams({
+            corpid: this.corpId,
+            corpsecret: this.kfSecret,
+        });
+        const data = await this.#fetchJson(`${this.baseUrl}/cgi-bin/gettoken?${query}`, { method: 'GET' }, 'gettoken');
+        const errorCode = Number(data.errcode || 0);
+        if (errorCode !== 0) {
+            throw new WecomApiError(`gettoken failed: ${errorCode} ${data.errmsg || ''}`.trim(), { code: errorCode, data });
+        }
+        if (!data.access_token || !Number.isFinite(Number(data.expires_in))) {
+            throw new WecomApiError('gettoken returned an invalid response', { data });
+        }
+        const expiresIn = Math.max(60, Number(data.expires_in) - 300);
+        this.tokenCache = {
+            value: String(data.access_token),
+            expiresAt: Date.now() + expiresIn * 1000,
+        };
+        return this.tokenCache.value;
+    }
+    async #fetchJson(url, options, operation) {
+        let response;
+        try {
+            response = await this.fetch(url, {
+                ...options,
+                signal: AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch (error) {
+            throw new WecomApiError(`${operation} request failed: ${errorMessage(error)}`);
+        }
+        const responseText = await response.text();
+        let data;
+        try {
+            data = JSON.parse(responseText);
+        }
+        catch {
+            throw new WecomApiError(`${operation} returned non-JSON HTTP ${response.status}`);
+        }
+        if (!response.ok) {
+            throw new WecomApiError(`${operation} returned HTTP ${response.status}`, { data });
+        }
+        return data;
+    }
+    async #postApi(path, body, retryAccessToken = true) {
+        const accessToken = await this.getAccessToken();
+        const query = new URLSearchParams({ access_token: accessToken });
+        const data = await this.#fetchJson(`${this.baseUrl}${path}?${query}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        }, path);
+        const errorCode = Number(data.errcode || 0);
+        if (retryAccessToken && INVALID_ACCESS_TOKEN_CODES.has(errorCode)) {
+            this.clearAccessToken();
+            return this.#postApi(path, body, false);
+        }
+        if (errorCode !== 0) {
+            throw new WecomApiError(`${path} failed: ${errorCode} ${data.errmsg || ''}`.trim(), { code: errorCode, data });
+        }
+        return data;
+    }
+    async #downloadMedia(mediaId, retryAccessToken = true) {
+        const accessToken = await this.getAccessToken();
+        const query = new URLSearchParams({
+            access_token: accessToken,
+            media_id: mediaId,
+        });
+        let response;
+        try {
+            response = await this.fetch(`${this.baseUrl}/cgi-bin/media/get?${query}`, { method: 'GET', signal: AbortSignal.timeout(this.timeoutMs) });
+        }
+        catch (error) {
+            throw new WecomApiError(`media/get request failed: ${errorMessage(error)}`);
+        }
+        const contentType = (String(response.headers.get('content-type') || '')
+            .split(';')[0] ?? '')
+            .trim()
+            .toLowerCase();
+        if (contentType === 'application/json' || contentType === 'text/json') {
+            const data = (await response.json());
+            const errorCode = Number(data.errcode || 0);
+            if (retryAccessToken && INVALID_ACCESS_TOKEN_CODES.has(errorCode)) {
+                this.clearAccessToken();
+                return this.#downloadMedia(mediaId, false);
+            }
+            throw new WecomApiError(`media/get failed: ${errorCode} ${data.errmsg || ''}`.trim(), { code: errorCode, data });
+        }
+        if (!response.ok) {
+            throw new WecomApiError(`media/get returned HTTP ${response.status}`);
+        }
+        return {
+            bytes: await readLimitedBody(response),
+            contentType,
+            filename: responseFilename(response.headers.get('content-disposition')),
+        };
+    }
+    async #uploadMedia({ type, bytes, filename, contentType }, retryAccessToken = true) {
+        const accessToken = await this.getAccessToken();
+        const query = new URLSearchParams({ access_token: accessToken, type });
+        const multipart = createMultipartBody({ bytes, filename, contentType });
+        const data = await this.#fetchJson(`${this.baseUrl}/cgi-bin/media/upload?${query}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': multipart.contentType,
+                'Content-Length': String(multipart.body.length),
+            },
+            body: multipart.body,
+        }, 'media/upload');
+        const errorCode = Number(data.errcode || 0);
+        if (retryAccessToken && INVALID_ACCESS_TOKEN_CODES.has(errorCode)) {
+            this.clearAccessToken();
+            return this.#uploadMedia({ type, bytes, filename, contentType }, false);
+        }
+        if (errorCode !== 0 || !data.media_id) {
+            throw new WecomApiError(`media/upload failed: ${errorCode} ${data.errmsg || ''}`.trim(), { code: errorCode, data });
+        }
+        return data;
+    }
+    async syncMessages({ cursor, callbackToken, openKfId, limit = 1000, voiceFormat = 0, }) {
+        const body = { limit, voice_format: voiceFormat };
+        if (cursor)
+            body.cursor = cursor;
+        if (callbackToken)
+            body.token = callbackToken;
+        if (openKfId)
+            body.open_kfid = openKfId;
+        const data = await this.#postApi('/cgi-bin/kf/sync_msg', body);
+        return {
+            ...data,
+            has_more: Number(data.has_more || 0),
+            msg_list: Array.isArray(data.msg_list)
+                ? data.msg_list
+                : [],
+        };
+    }
+    async sendPreparedMessage({ toUser, openKfId, payload, messageId = '', }) {
+        if (!toUser || !openKfId) {
+            throw new Error('toUser and openKfId are required');
+        }
+        const msgtype = String(payload?.msgtype || '');
+        if (!SEND_MESSAGE_TYPES.has(msgtype) || !payload?.[msgtype]) {
+            throw new Error('Prepared WeCom payload has an unsupported message type');
+        }
+        const exactPayload = structuredClone(payload);
+        for (const forbidden of ['touser', 'open_kfid', 'msgid']) {
+            if (Object.hasOwn(exactPayload, forbidden)) {
+                throw new Error(`Prepared WeCom payload must not contain ${forbidden}`);
+            }
+        }
+        return this.#postApi('/cgi-bin/kf/send_msg', withClientMessageId({ touser: toUser, open_kfid: openKfId, ...exactPayload }, messageId));
+    }
+    async downloadMedia(mediaId) {
+        const value = String(mediaId || '');
+        if (!value || value.length > MAX_MEDIA_ID_CHARACTERS) {
+            throw new Error('mediaId must contain 1 to 512 characters');
+        }
+        return this.#downloadMedia(value);
+    }
+    async uploadMedia({ type, bytes, filename, contentType, }) {
+        const limit = MEDIA_LIMITS[type];
+        if (!limit) {
+            throw new Error(`Unsupported WeCom media type: ${type}`);
+        }
+        if (!Buffer.isBuffer(bytes) || bytes.length <= 5 || bytes.length > limit) {
+            throw new Error(`WeCom ${type} media must contain 6 to ${limit} bytes`);
+        }
+        return this.#uploadMedia({ type, bytes, filename, contentType });
+    }
+}