@foxden-app/foxclaw 0.2.0

package/dist/channels/weixin/ilink/types.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Weixin iLink protocol types (from openclaw-weixin, MIT).
+ */
+export interface BaseInfo {
+    channel_version?: string;
+}
+export declare const UploadMediaType: {
+    readonly IMAGE: 1;
+    readonly VIDEO: 2;
+    readonly FILE: 3;
+    readonly VOICE: 4;
+};
+export interface GetUploadUrlReq {
+    filekey?: string;
+    media_type?: number;
+    to_user_id?: string;
+    rawsize?: number;
+    rawfilemd5?: string;
+    filesize?: number;
+    thumb_rawsize?: number;
+    thumb_rawfilemd5?: string;
+    thumb_filesize?: number;
+    no_need_thumb?: boolean;
+    aeskey?: string;
+}
+export interface GetUploadUrlResp {
+    upload_param?: string;
+    thumb_upload_param?: string;
+    upload_full_url?: string;
+}
+export declare const MessageType: {
+    readonly NONE: 0;
+    readonly USER: 1;
+    readonly BOT: 2;
+};
+export declare const MessageItemType: {
+    readonly NONE: 0;
+    readonly TEXT: 1;
+    readonly IMAGE: 2;
+    readonly VOICE: 3;
+    readonly FILE: 4;
+    readonly VIDEO: 5;
+};
+export declare const MessageState: {
+    readonly NEW: 0;
+    readonly GENERATING: 1;
+    readonly FINISH: 2;
+};
+export interface TextItem {
+    text?: string;
+}
+export interface CDNMedia {
+    encrypt_query_param?: string;
+    aes_key?: string;
+    encrypt_type?: number;
+    full_url?: string;
+}
+export interface ImageItem {
+    media?: CDNMedia;
+    thumb_media?: CDNMedia;
+    aeskey?: string;
+    url?: string;
+    mid_size?: number;
+    thumb_size?: number;
+    thumb_height?: number;
+    thumb_width?: number;
+    hd_size?: number;
+}
+export interface VoiceItem {
+    media?: CDNMedia;
+    encode_type?: number;
+    bits_per_sample?: number;
+    sample_rate?: number;
+    playtime?: number;
+    text?: string;
+}
+export interface FileItem {
+    media?: CDNMedia;
+    file_name?: string;
+    md5?: string;
+    len?: string;
+}
+export interface VideoItem {
+    media?: CDNMedia;
+    video_size?: number;
+    play_length?: number;
+    video_md5?: string;
+    thumb_media?: CDNMedia;
+    thumb_size?: number;
+    thumb_height?: number;
+    thumb_width?: number;
+}
+export interface RefMessage {
+    message_item?: MessageItem;
+    title?: string;
+}
+export interface MessageItem {
+    type?: number;
+    create_time_ms?: number;
+    update_time_ms?: number;
+    is_completed?: boolean;
+    msg_id?: string;
+    ref_msg?: RefMessage;
+    text_item?: TextItem;
+    image_item?: ImageItem;
+    voice_item?: VoiceItem;
+    file_item?: FileItem;
+    video_item?: VideoItem;
+}
+export interface WeixinMessage {
+    seq?: number;
+    message_id?: number;
+    from_user_id?: string;
+    to_user_id?: string;
+    client_id?: string;
+    create_time_ms?: number;
+    update_time_ms?: number;
+    delete_time_ms?: number;
+    session_id?: string;
+    group_id?: string;
+    message_type?: number;
+    message_state?: number;
+    item_list?: MessageItem[];
+    context_token?: string;
+}
+export interface GetUpdatesReq {
+    sync_buf?: string;
+    get_updates_buf?: string;
+}
+export interface GetUpdatesResp {
+    ret?: number;
+    errcode?: number;
+    errmsg?: string;
+    msgs?: WeixinMessage[];
+    sync_buf?: string;
+    get_updates_buf?: string;
+    longpolling_timeout_ms?: number;
+}
+export interface SendMessageReq {
+    msg?: WeixinMessage;
+}
+export declare const TypingStatus: {
+    readonly TYPING: 1;
+    readonly CANCEL: 2;
+};
+export interface SendTypingReq {
+    ilink_user_id?: string;
+    typing_ticket?: string;
+    status?: number;
+}
+export interface GetConfigResp {
+    ret?: number;
+    errmsg?: string;
+    typing_ticket?: string;
+}

package/dist/channels/weixin/ilink/types.js

@@ -0,0 +1,10 @@
+export const UploadMediaType = {
+    IMAGE: 1,
+    VIDEO: 2,
+    FILE: 3,
+    VOICE: 4,
+};
+export const MessageType = { NONE: 0, USER: 1, BOT: 2 };
+export const MessageItemType = { NONE: 0, TEXT: 1, IMAGE: 2, VOICE: 3, FILE: 4, VIDEO: 5 };
+export const MessageState = { NEW: 0, GENERATING: 1, FINISH: 2 };
+export const TypingStatus = { TYPING: 1, CANCEL: 2 };

package/dist/channels/weixin/ilink/upload.d.ts

@@ -0,0 +1,15 @@
+import type { WeixinApiOptions } from './api.js';
+export type UploadedFileInfo = {
+    filekey: string;
+    downloadEncryptedQueryParam: string;
+    aeskey: string;
+    fileSize: number;
+    fileSizeCiphertext: number;
+};
+export declare function uploadFileToWeixin(params: {
+    filePath: string;
+    toUserId: string;
+    opts: WeixinApiOptions;
+    cdnBaseUrl: string;
+}): Promise<UploadedFileInfo>;
+export declare function downloadRemoteImageToTemp(url: string, destDir: string): Promise<string>;

package/dist/channels/weixin/ilink/upload.js

@@ -0,0 +1,75 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getUploadUrl } from './api.js';
+import { aesEcbPaddedSize } from './aes_ecb.js';
+import { uploadBufferToCdn } from './cdn_upload.js';
+import { getIlinkRuntimeContext } from './context.js';
+import { getExtensionFromContentTypeOrUrl } from './mime.js';
+import { tempFileName } from './random.js';
+import { UploadMediaType } from './types.js';
+async function uploadMediaToCdn(params) {
+    const log = getIlinkRuntimeContext().logger;
+    const { filePath, toUserId, opts, cdnBaseUrl, mediaType, label } = params;
+    const plaintext = await fs.readFile(filePath);
+    const rawsize = plaintext.length;
+    const rawfilemd5 = crypto.createHash('md5').update(plaintext).digest('hex');
+    const filesize = aesEcbPaddedSize(rawsize);
+    const filekey = crypto.randomBytes(16).toString('hex');
+    const aeskey = crypto.randomBytes(16);
+    log.debug(`${label}: file=${filePath} rawsize=${rawsize} filekey=${filekey}`);
+    const uploadUrlResp = await getUploadUrl({
+        ...opts,
+        filekey,
+        media_type: mediaType,
+        to_user_id: toUserId,
+        rawsize,
+        rawfilemd5,
+        filesize,
+        no_need_thumb: true,
+        aeskey: aeskey.toString('hex'),
+    });
+    const uploadFullUrl = uploadUrlResp.upload_full_url?.trim();
+    const uploadParam = uploadUrlResp.upload_param;
+    if (!uploadFullUrl && !uploadParam) {
+        throw new Error(`${label}: getUploadUrl returned no upload URL`);
+    }
+    const { downloadParam } = await uploadBufferToCdn({
+        buf: plaintext,
+        filekey,
+        cdnBaseUrl,
+        aeskey,
+        label: `${label}[filekey=${filekey}]`,
+        ...(uploadFullUrl ? { uploadFullUrl } : {}),
+        ...(uploadParam ? { uploadParam } : {}),
+    });
+    return {
+        filekey,
+        downloadEncryptedQueryParam: downloadParam,
+        aeskey: aeskey.toString('hex'),
+        fileSize: rawsize,
+        fileSizeCiphertext: filesize,
+    };
+}
+export async function uploadFileToWeixin(params) {
+    return uploadMediaToCdn({
+        ...params,
+        mediaType: UploadMediaType.IMAGE,
+        label: 'uploadFileToWeixin',
+    });
+}
+export async function downloadRemoteImageToTemp(url, destDir) {
+    const log = getIlinkRuntimeContext().logger;
+    log.debug(`downloadRemoteImageToTemp: fetching url=${url}`);
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`remote media download failed: ${res.status} url=${url}`);
+    }
+    const buf = Buffer.from(await res.arrayBuffer());
+    await fs.mkdir(destDir, { recursive: true });
+    const ext = getExtensionFromContentTypeOrUrl(res.headers.get('content-type'), url);
+    const name = tempFileName('weixin-remote', ext);
+    const filePath = path.join(destDir, name);
+    await fs.writeFile(filePath, buf);
+    return filePath;
+}

package/dist/channels/weixin/sync_buf_store.d.ts

@@ -0,0 +1,3 @@
+export declare function getWeixinSyncBufPath(syncBufDir: string, accountId: string): string;
+export declare function loadGetUpdatesBuf(filePath: string): string | null;
+export declare function saveGetUpdatesBuf(filePath: string, buf: string): void;

package/dist/channels/weixin/sync_buf_store.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function getWeixinSyncBufPath(syncBufDir, accountId) {
+    const safe = accountId.replace(/[^\w.-]+/g, '-');
+    return path.join(syncBufDir, `${safe}.buf`);
+}
+export function loadGetUpdatesBuf(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8').trim();
+        return raw.length ? raw : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveGetUpdatesBuf(filePath, buf) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, buf, 'utf-8');
+}

package/dist/channels/weixin/weixin_channel_adapter.d.ts

@@ -0,0 +1,18 @@
+import type { AppConfig } from '../../config.js';
+import type { BridgeSessionCore } from '../../controller/controller.js';
+import type { Logger } from '../../logger.js';
+import type { BridgeStore } from '../../store/database.js';
+export declare class WeixinChannelAdapter {
+    private readonly core;
+    private readonly store;
+    private readonly config;
+    private readonly logger;
+    private readonly abort;
+    private loops;
+    constructor(core: BridgeSessionCore, store: BridgeStore, config: AppConfig, logger: Logger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private listAccounts;
+    private runAccountLoop;
+    private dispatchOneMessage;
+}

package/dist/channels/weixin/weixin_channel_adapter.js

@@ -0,0 +1,273 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { toWeixinBridgeScopeId } from '../../core/bridge_scope.js';
+import { getUpdates } from './ilink/api.js';
+import { DEFAULT_CDN_BASE_URL } from './ilink/constants.js';
+import { downloadWeixinImageItemToFile } from './ilink/media_image.js';
+import { SESSION_EXPIRED_ERRCODE, getRemainingPauseMs, pauseSession, } from './ilink/session_guard.js';
+import { MessageItemType, MessageType } from './ilink/types.js';
+import { getWeixinSyncBufPath, loadGetUpdatesBuf, saveGetUpdatesBuf } from './sync_buf_store.js';
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const BACKOFF_DELAY_MS = 30_000;
+const RETRY_DELAY_MS = 2_000;
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, ms);
+        signal.addEventListener('abort', () => {
+            clearTimeout(t);
+            reject(new Error('aborted'));
+        }, { once: true });
+    });
+}
+function isAllowedWeixinUser(config, fromUserId) {
+    if (config.wxAllowedIlinkUserIds.length === 0) {
+        return true;
+    }
+    return config.wxAllowedIlinkUserIds.includes(fromUserId);
+}
+function buildTelegramShapedEvent(params) {
+    return {
+        chatId: params.fromUserId,
+        topicId: null,
+        scopeId: params.scopeId,
+        chatType: 'private',
+        userId: params.fromUserId,
+        text: params.text,
+        messageId: params.messageId,
+        attachments: params.attachments,
+        entities: [],
+        replyToBot: false,
+        languageCode: 'zh',
+    };
+}
+function normalizeInboundBaseUrl(account) {
+    const raw = account.baseUrl.trim();
+    if (raw.startsWith('http://') || raw.startsWith('https://')) {
+        return raw;
+    }
+    return `https://${raw}`;
+}
+export class WeixinChannelAdapter {
+    core;
+    store;
+    config;
+    logger;
+    abort = new AbortController();
+    loops = [];
+    constructor(core, store, config, logger) {
+        this.core = core;
+        this.store = store;
+        this.config = config;
+        this.logger = logger;
+    }
+    async start() {
+        const accounts = this.listAccounts();
+        if (accounts.length === 0) {
+            this.logger.warn('weixin.start_no_accounts', { dir: this.config.weixinAccountsDir });
+            return;
+        }
+        for (const account of accounts) {
+            this.loops.push(this.runAccountLoop(account));
+        }
+    }
+    async stop() {
+        this.abort.abort();
+        await Promise.allSettled(this.loops);
+        this.loops = [];
+    }
+    listAccounts() {
+        if (!this.config.wxEnabled) {
+            return [];
+        }
+        if (!fs.existsSync(this.config.weixinAccountsDir)) {
+            return [];
+        }
+        const out = [];
+        for (const name of fs.readdirSync(this.config.weixinAccountsDir)) {
+            if (!name.endsWith('.json'))
+                continue;
+            try {
+                const raw = fs.readFileSync(path.join(this.config.weixinAccountsDir, name), 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (parsed.accountId && parsed.botToken && parsed.baseUrl) {
+                    out.push(parsed);
+                }
+            }
+            catch {
+                // skip invalid
+            }
+        }
+        return out;
+    }
+    async runAccountLoop(account) {
+        const accountId = account.accountId;
+        const baseUrl = normalizeInboundBaseUrl(account);
+        const cdnBaseUrl = DEFAULT_CDN_BASE_URL;
+        const syncPath = getWeixinSyncBufPath(this.config.weixinSyncBufDir, accountId);
+        let getUpdatesBuf = loadGetUpdatesBuf(syncPath) ?? '';
+        let nextTimeoutMs = DEFAULT_LONG_POLL_TIMEOUT_MS;
+        let consecutiveFailures = 0;
+        const signal = this.abort.signal;
+        const inboundTemp = path.join(this.config.weixinMediaDir, 'inbound-temp', accountId);
+        this.logger.info('weixin.monitor_started', { accountId, baseUrl });
+        while (!signal.aborted) {
+            try {
+                const resp = await getUpdates({
+                    baseUrl,
+                    token: account.botToken,
+                    get_updates_buf: getUpdatesBuf,
+                    timeoutMs: nextTimeoutMs,
+                });
+                if (resp.longpolling_timeout_ms != null && resp.longpolling_timeout_ms > 0) {
+                    nextTimeoutMs = resp.longpolling_timeout_ms;
+                }
+                const isApiError = (resp.ret !== undefined && resp.ret !== 0) ||
+                    (resp.errcode !== undefined && resp.errcode !== 0);
+                if (isApiError) {
+                    const isSessionExpired = resp.errcode === SESSION_EXPIRED_ERRCODE || resp.ret === SESSION_EXPIRED_ERRCODE;
+                    if (isSessionExpired) {
+                        pauseSession(accountId);
+                        const pauseMs = getRemainingPauseMs(accountId);
+                        this.logger.error('weixin.session_expired', { accountId, pauseMs });
+                        consecutiveFailures = 0;
+                        try {
+                            await sleep(pauseMs, signal);
+                        }
+                        catch {
+                            return;
+                        }
+                        continue;
+                    }
+                    consecutiveFailures += 1;
+                    this.logger.warn('weixin.getupdates_failed', {
+                        accountId,
+                        ret: resp.ret,
+                        errcode: resp.errcode,
+                        consecutiveFailures,
+                    });
+                    if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                        consecutiveFailures = 0;
+                        try {
+                            await sleep(BACKOFF_DELAY_MS, signal);
+                        }
+                        catch {
+                            return;
+                        }
+                    }
+                    else {
+                        try {
+                            await sleep(RETRY_DELAY_MS, signal);
+                        }
+                        catch {
+                            return;
+                        }
+                    }
+                    continue;
+                }
+                consecutiveFailures = 0;
+                if (resp.get_updates_buf != null && resp.get_updates_buf !== '') {
+                    saveGetUpdatesBuf(syncPath, resp.get_updates_buf);
+                    getUpdatesBuf = resp.get_updates_buf;
+                }
+                for (const msg of resp.msgs ?? []) {
+                    await this.dispatchOneMessage(msg, accountId, cdnBaseUrl, inboundTemp);
+                }
+            }
+            catch (err) {
+                if (signal.aborted) {
+                    return;
+                }
+                consecutiveFailures += 1;
+                this.logger.error('weixin.poll_error', { accountId, error: String(err) });
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                    consecutiveFailures = 0;
+                    try {
+                        await sleep(BACKOFF_DELAY_MS, signal);
+                    }
+                    catch {
+                        return;
+                    }
+                }
+                else {
+                    try {
+                        await sleep(RETRY_DELAY_MS, signal);
+                    }
+                    catch {
+                        return;
+                    }
+                }
+            }
+        }
+    }
+    async dispatchOneMessage(msg, accountId, cdnBaseUrl, inboundTemp) {
+        if (msg.message_type === MessageType.BOT) {
+            return;
+        }
+        const fromUserId = msg.from_user_id?.trim() ?? '';
+        if (!fromUserId) {
+            return;
+        }
+        if (!isAllowedWeixinUser(this.config, fromUserId)) {
+            this.logger.debug('weixin.inbound_denied', { accountId, fromUserId });
+            return;
+        }
+        const scopeId = toWeixinBridgeScopeId(accountId, fromUserId);
+        if (msg.context_token) {
+            this.store.setWeixinContextToken(scopeId, msg.context_token);
+        }
+        let text = '';
+        const attachments = [];
+        const items = msg.item_list ?? [];
+        for (const item of items) {
+            if (item.type === MessageItemType.TEXT) {
+                text += item.text_item?.text ?? '';
+            }
+            else if (item.type === MessageItemType.IMAGE) {
+                const localPath = await downloadWeixinImageItemToFile({
+                    item,
+                    cdnBaseUrl,
+                    destDir: inboundTemp,
+                    label: `${scopeId}`,
+                });
+                if (localPath) {
+                    attachments.push({
+                        kind: 'document',
+                        fileId: 'weixin-image',
+                        fileUniqueId: `wx-${msg.message_id ?? Date.now()}-${attachments.length}`,
+                        fileName: path.basename(localPath),
+                        mimeType: 'image/jpeg',
+                        fileSize: null,
+                        width: null,
+                        height: null,
+                        durationSeconds: null,
+                        isAnimated: false,
+                        isVideo: false,
+                        localPath,
+                    });
+                }
+            }
+        }
+        const trimmed = text.trim();
+        if (!trimmed && attachments.length === 0) {
+            return;
+        }
+        const midRaw = Number(msg.message_id);
+        const messageId = Number.isFinite(midRaw) ? midRaw : Math.floor(Math.random() * 1_000_000_000);
+        this.logger.info('weixin.inbound', {
+            accountId,
+            fromUserId,
+            scopeId,
+            textLen: trimmed.length,
+            attachments: attachments.length,
+        });
+        const event = buildTelegramShapedEvent({
+            scopeId,
+            fromUserId,
+            text: trimmed,
+            messageId,
+            attachments,
+        });
+        this.core.dispatchInboundLikeTelegramText(event);
+    }
+}

package/dist/channels/weixin/weixin_messaging_port.d.ts

@@ -0,0 +1,29 @@
+import type { BridgeStore } from '../../store/database.js';
+import { getConfig, sendTyping } from './ilink/api.js';
+import type { WeixinSavedAccount } from './account_store.js';
+import type { ChannelInlineKeyboard } from '../../core/channel_port.js';
+type WeixinTypingApi = {
+    getConfig: typeof getConfig;
+    sendTyping: typeof sendTyping;
+};
+/**
+ * Weixin (iLink) outbound: addressed by `weixin:<accountId>:<peerUserId>` scope ids.
+ * Editing/deleting Telegram messages is approximated as new plain text sends or no-ops.
+ */
+export declare class WeixinMessagingPort {
+    private readonly store;
+    private readonly loadAccount;
+    private readonly typingApi;
+    private nextSyntheticId;
+    constructor(store: BridgeStore, loadAccount: (accountId: string) => WeixinSavedAccount | null, typingApi?: WeixinTypingApi);
+    private allocMessageId;
+    sendPlain(scopeId: string, text: string, keyboard?: ChannelInlineKeyboard): Promise<number>;
+    sendHtml(scopeId: string, html: string, keyboard?: ChannelInlineKeyboard): Promise<number>;
+    editPlain(scopeId: string, _messageId: number, text: string, keyboard?: ChannelInlineKeyboard): Promise<void>;
+    editHtml(scopeId: string, messageId: number, html: string, keyboard?: ChannelInlineKeyboard): Promise<void>;
+    deleteMessage(scopeId: string, messageId: number): Promise<void>;
+    sendTypingInScope(scopeId: string): Promise<void>;
+    clearInlineKeyboard(scopeId: string, messageId: number): Promise<void>;
+    sendDraft(scopeId: string, _draftId: number, text: string): Promise<void>;
+}
+export {};