@foxden-app/foxclaw 0.2.0

package/dist/channels/telegram/telegram_channel_adapter.js

@@ -0,0 +1,21 @@
+/**
+ * Telegram channel: inbound subscription + transport startup ordering for {@link BridgeSessionCore}.
+ * Additional channels (e.g. Weixin) can compose the same core with their own adapters.
+ */
+export class TelegramChannelAdapter {
+    core;
+    constructor(core) {
+        this.core = core;
+    }
+    async start() {
+        this.core.registerTelegramInboundHandlers();
+        await this.core.startCodexApp();
+        await this.core.startTelegramPolling();
+    }
+    async stop() {
+        await this.core.stop();
+    }
+    get sessionCore() {
+        return this.core;
+    }
+}

package/dist/channels/telegram/telegram_messaging_port.d.ts

@@ -0,0 +1,25 @@
+import type { ChannelPort } from '../../core/channel_port.js';
+import type { TelegramGateway } from '../../telegram/gateway.js';
+import type { TelegramRemoteFile } from '../../telegram/api.js';
+export type InlineKeyboard = Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+/**
+ * Telegram outbound operations addressed by bridge scope id (`telegram:…`).
+ */
+export declare class TelegramMessagingPort implements ChannelPort {
+    private readonly gateway;
+    constructor(gateway: TelegramGateway);
+    sendPlain(bridgeScopeId: string, text: string, inlineKeyboard?: InlineKeyboard): Promise<number>;
+    sendHtml(bridgeScopeId: string, text: string, inlineKeyboard?: InlineKeyboard): Promise<number>;
+    editPlain(bridgeScopeId: string, messageId: number, text: string, inlineKeyboard?: InlineKeyboard): Promise<void>;
+    editHtml(bridgeScopeId: string, messageId: number, text: string, inlineKeyboard?: InlineKeyboard): Promise<void>;
+    deleteMessage(bridgeScopeId: string, messageId: number): Promise<void>;
+    sendTypingInScope(bridgeScopeId: string): Promise<void>;
+    clearInlineKeyboard(bridgeScopeId: string, messageId: number): Promise<void>;
+    sendDraft(bridgeScopeId: string, draftId: number, text: string): Promise<void>;
+    answerCallback(callbackQueryId: string, text: string): Promise<void>;
+    getFile(fileId: string): Promise<TelegramRemoteFile>;
+    downloadResolvedFile(remoteFilePath: string, destinationPath: string): Promise<number>;
+}

package/dist/channels/telegram/telegram_messaging_port.js

@@ -0,0 +1,51 @@
+import { parseTelegramTargetFromBridgeScope } from '../../core/bridge_scope.js';
+/**
+ * Telegram outbound operations addressed by bridge scope id (`telegram:…`).
+ */
+export class TelegramMessagingPort {
+    gateway;
+    constructor(gateway) {
+        this.gateway = gateway;
+    }
+    async sendPlain(bridgeScopeId, text, inlineKeyboard) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        return this.gateway.sendMessage(target.chatId, text, inlineKeyboard, target.topicId);
+    }
+    async sendHtml(bridgeScopeId, text, inlineKeyboard) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        return this.gateway.sendHtmlMessage(target.chatId, text, inlineKeyboard, target.topicId);
+    }
+    async editPlain(bridgeScopeId, messageId, text, inlineKeyboard) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.editMessage(target.chatId, messageId, text, inlineKeyboard);
+    }
+    async editHtml(bridgeScopeId, messageId, text, inlineKeyboard) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.editHtmlMessage(target.chatId, messageId, text, inlineKeyboard);
+    }
+    async deleteMessage(bridgeScopeId, messageId) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.deleteMessage(target.chatId, messageId);
+    }
+    async sendTypingInScope(bridgeScopeId) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.sendTypingInThread(target.chatId, target.topicId);
+    }
+    async clearInlineKeyboard(bridgeScopeId, messageId) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.clearMessageInlineKeyboard(target.chatId, messageId);
+    }
+    async sendDraft(bridgeScopeId, draftId, text) {
+        const target = parseTelegramTargetFromBridgeScope(bridgeScopeId);
+        await this.gateway.sendMessageDraft(target.chatId, draftId, text, target.topicId);
+    }
+    answerCallback(callbackQueryId, text) {
+        return this.gateway.answerCallback(callbackQueryId, text);
+    }
+    getFile(fileId) {
+        return this.gateway.getFile(fileId);
+    }
+    downloadResolvedFile(remoteFilePath, destinationPath) {
+        return this.gateway.downloadResolvedFile(remoteFilePath, destinationPath);
+    }
+}

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

@@ -0,0 +1,15 @@
+/** Persisted after QR login; `accountId` is ilink_bot_id from iLink. */
+export interface WeixinSavedAccount {
+    accountId: string;
+    botToken: string;
+    baseUrl: string;
+    /** User who scanned QR (reference only). */
+    linkedIlinkUserId?: string;
+    savedAt: number;
+}
+export declare function defaultWeixinAccountsDir(appHome: string): string;
+export declare function accountFilePath(accountsDir: string, accountId: string): string;
+export declare function saveWeixinAccount(accountsDir: string, record: WeixinSavedAccount): void;
+export declare function loadWeixinAccount(accountsDir: string, accountId: string): WeixinSavedAccount | null;
+export declare function listWeixinAccountIds(accountsDir: string): string[];
+export declare function listWeixinAccounts(accountsDir: string): WeixinSavedAccount[];

package/dist/channels/weixin/account_store.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function defaultWeixinAccountsDir(appHome) {
+    return path.join(appHome, 'weixin', 'accounts');
+}
+export function accountFilePath(accountsDir, accountId) {
+    const safe = accountId.replace(/[^\w.-]+/g, '-');
+    return path.join(accountsDir, `${safe}.json`);
+}
+export function saveWeixinAccount(accountsDir, record) {
+    fs.mkdirSync(accountsDir, { recursive: true });
+    const filePath = accountFilePath(accountsDir, record.accountId);
+    fs.writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf-8');
+}
+export function loadWeixinAccount(accountsDir, accountId) {
+    const filePath = accountFilePath(accountsDir, accountId);
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed.accountId || !parsed.botToken || !parsed.baseUrl) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function listWeixinAccountIds(accountsDir) {
+    if (!fs.existsSync(accountsDir)) {
+        return [];
+    }
+    const ids = [];
+    for (const name of fs.readdirSync(accountsDir)) {
+        if (!name.endsWith('.json'))
+            continue;
+        try {
+            const raw = fs.readFileSync(path.join(accountsDir, name), 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (parsed.accountId) {
+                ids.push(parsed.accountId);
+            }
+        }
+        catch {
+            // skip invalid
+        }
+    }
+    return ids;
+}
+export function listWeixinAccounts(accountsDir) {
+    return listWeixinAccountIds(accountsDir)
+        .map((id) => loadWeixinAccount(accountsDir, id))
+        .filter((a) => a !== null);
+}

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

@@ -0,0 +1,3 @@
+export declare function encryptAesEcb(plaintext: Buffer, key: Buffer): Buffer;
+export declare function decryptAesEcb(ciphertext: Buffer, key: Buffer): Buffer;
+export declare function aesEcbPaddedSize(plaintextSize: number): number;

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

@@ -0,0 +1,12 @@
+import { createCipheriv, createDecipheriv } from 'node:crypto';
+export function encryptAesEcb(plaintext, key) {
+    const cipher = createCipheriv('aes-128-ecb', key, null);
+    return Buffer.concat([cipher.update(plaintext), cipher.final()]);
+}
+export function decryptAesEcb(ciphertext, key) {
+    const decipher = createDecipheriv('aes-128-ecb', key, null);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+export function aesEcbPaddedSize(plaintextSize) {
+    return Math.ceil((plaintextSize + 1) / 16) * 16;
+}

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

@@ -0,0 +1,44 @@
+import { ILINK_APP_ID } from './constants.js';
+import type { BaseInfo, GetUpdatesReq, GetUpdatesResp, SendMessageReq, SendTypingReq, GetConfigResp } from './types.js';
+export type WeixinApiOptions = {
+    baseUrl: string;
+    token?: string;
+    timeoutMs?: number;
+    longPollTimeoutMs?: number;
+};
+export declare function buildBaseInfo(): BaseInfo;
+export declare function apiGetFetch(params: {
+    baseUrl: string;
+    endpoint: string;
+    timeoutMs?: number;
+    label: string;
+}): Promise<string>;
+export declare function getUpdates(params: GetUpdatesReq & {
+    baseUrl: string;
+    token?: string;
+    timeoutMs?: number;
+}): Promise<GetUpdatesResp>;
+export declare function getUploadUrl(params: WeixinApiOptions & {
+    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;
+}): Promise<import('./types.js').GetUploadUrlResp>;
+export declare function sendMessage(params: WeixinApiOptions & {
+    body: SendMessageReq;
+}): Promise<void>;
+export declare function getConfig(params: WeixinApiOptions & {
+    ilinkUserId: string;
+    contextToken?: string;
+}): Promise<GetConfigResp>;
+export declare function sendTyping(params: WeixinApiOptions & {
+    body: SendTypingReq;
+}): Promise<void>;
+export { ILINK_APP_ID };

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

@@ -0,0 +1,187 @@
+import crypto from 'node:crypto';
+import { BRIDGE_PACKAGE_VERSION, ILINK_APP_ID } from './constants.js';
+import { getIlinkRuntimeContext } from './context.js';
+import { redactBody, redactUrl } from './redact.js';
+export function buildBaseInfo() {
+    return { channel_version: BRIDGE_PACKAGE_VERSION };
+}
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+const DEFAULT_API_TIMEOUT_MS = 15_000;
+const DEFAULT_CONFIG_TIMEOUT_MS = 10_000;
+function ensureTrailingSlash(url) {
+    return url.endsWith('/') ? url : `${url}/`;
+}
+function randomWechatUin() {
+    const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), 'utf-8').toString('base64');
+}
+function buildCommonHeaders() {
+    const rt = getIlinkRuntimeContext();
+    const headers = {
+        'iLink-App-Id': rt.ilinkAppId,
+        'iLink-App-ClientVersion': String(rt.ilinkAppClientVersion),
+    };
+    if (rt.routeTag?.trim()) {
+        headers.SKRouteTag = rt.routeTag.trim();
+    }
+    return headers;
+}
+function buildHeaders(opts) {
+    const headers = {
+        'Content-Type': 'application/json',
+        AuthorizationType: 'ilink_bot_token',
+        'Content-Length': String(Buffer.byteLength(opts.body, 'utf-8')),
+        'X-WECHAT-UIN': randomWechatUin(),
+        ...buildCommonHeaders(),
+    };
+    if (opts.token?.trim()) {
+        headers.Authorization = `Bearer ${opts.token.trim()}`;
+    }
+    return headers;
+}
+export async function apiGetFetch(params) {
+    const log = getIlinkRuntimeContext().logger;
+    const base = ensureTrailingSlash(params.baseUrl);
+    const url = new URL(params.endpoint, base);
+    const hdrs = buildCommonHeaders();
+    log.debug(`GET ${redactUrl(url.toString())}`);
+    const timeoutMs = params.timeoutMs;
+    const controller = timeoutMs != null && timeoutMs > 0 ? new AbortController() : undefined;
+    const t = controller != null && timeoutMs != null ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    try {
+        const res = await fetch(url.toString(), {
+            method: 'GET',
+            headers: hdrs,
+            ...(controller ? { signal: controller.signal } : {}),
+        });
+        if (t !== undefined)
+            clearTimeout(t);
+        const rawText = await res.text();
+        log.debug(`${params.label} status=${res.status} raw=${redactBody(rawText)}`);
+        if (!res.ok) {
+            throw new Error(`${params.label} ${res.status}: ${rawText}`);
+        }
+        return rawText;
+    }
+    catch (err) {
+        if (t !== undefined)
+            clearTimeout(t);
+        throw err;
+    }
+}
+async function apiPostFetch(params) {
+    const log = getIlinkRuntimeContext().logger;
+    const base = ensureTrailingSlash(params.baseUrl);
+    const url = new URL(params.endpoint, base);
+    const hdrs = buildHeaders({
+        body: params.body,
+        ...(params.token !== undefined && params.token !== '' ? { token: params.token } : {}),
+    });
+    log.debug(`POST ${redactUrl(url.toString())} body=${redactBody(params.body)}`);
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), params.timeoutMs);
+    try {
+        const res = await fetch(url.toString(), {
+            method: 'POST',
+            headers: hdrs,
+            body: params.body,
+            signal: controller.signal,
+        });
+        clearTimeout(t);
+        const rawText = await res.text();
+        log.debug(`${params.label} status=${res.status} raw=${redactBody(rawText)}`);
+        if (!res.ok) {
+            throw new Error(`${params.label} ${res.status}: ${rawText}`);
+        }
+        return rawText;
+    }
+    catch (err) {
+        clearTimeout(t);
+        throw err;
+    }
+}
+export async function getUpdates(params) {
+    const log = getIlinkRuntimeContext().logger;
+    const timeout = params.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+    try {
+        const rawText = await apiPostFetch({
+            baseUrl: params.baseUrl,
+            endpoint: 'ilink/bot/getupdates',
+            body: JSON.stringify({
+                get_updates_buf: params.get_updates_buf ?? '',
+                base_info: buildBaseInfo(),
+            }),
+            timeoutMs: timeout,
+            label: 'getUpdates',
+            ...(params.token !== undefined && params.token !== '' ? { token: params.token } : {}),
+        });
+        return JSON.parse(rawText);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            log.debug(`getUpdates: client-side timeout after ${timeout}ms, returning empty response`);
+            return { ret: 0, msgs: [], get_updates_buf: params.get_updates_buf ?? '' };
+        }
+        throw err;
+    }
+}
+export async function getUploadUrl(params) {
+    const rawText = await apiPostFetch({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/getuploadurl',
+        body: JSON.stringify({
+            filekey: params.filekey,
+            media_type: params.media_type,
+            to_user_id: params.to_user_id,
+            rawsize: params.rawsize,
+            rawfilemd5: params.rawfilemd5,
+            filesize: params.filesize,
+            thumb_rawsize: params.thumb_rawsize,
+            thumb_rawfilemd5: params.thumb_rawfilemd5,
+            thumb_filesize: params.thumb_filesize,
+            no_need_thumb: params.no_need_thumb,
+            aeskey: params.aeskey,
+            base_info: buildBaseInfo(),
+        }),
+        timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+        label: 'getUploadUrl',
+        ...(params.token !== undefined && params.token !== '' ? { token: params.token } : {}),
+    });
+    return JSON.parse(rawText);
+}
+export async function sendMessage(params) {
+    await apiPostFetch({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/sendmessage',
+        body: JSON.stringify({ ...params.body, base_info: buildBaseInfo() }),
+        timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
+        label: 'sendMessage',
+        ...(params.token !== undefined && params.token !== '' ? { token: params.token } : {}),
+    });
+}
+export async function getConfig(params) {
+    const rawText = await apiPostFetch({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/getconfig',
+        body: JSON.stringify({
+            ilink_user_id: params.ilinkUserId,
+            context_token: params.contextToken,
+            base_info: buildBaseInfo(),
+        }),
+        timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+        label: 'getConfig',
+        ...(params.token !== undefined && params.token !== '' ? { token: params.token } : {}),
+    });
+    return JSON.parse(rawText);
+}
+export async function sendTyping(params) {
+    await apiPostFetch({
+        baseUrl: params.baseUrl,
+        endpoint: 'ilink/bot/sendtyping',
+        body: JSON.stringify({ ...params.body, base_info: buildBaseInfo() }),
+        timeoutMs: params.timeoutMs ?? DEFAULT_CONFIG_TIMEOUT_MS,
+        label: 'sendTyping',
+        ...(params.token !== undefined && params.token !== '' ? { token: params.token } : {}),
+    });
+}
+export { ILINK_APP_ID };

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

@@ -0,0 +1,11 @@
+export declare function uploadBufferToCdn(params: {
+    buf: Buffer;
+    uploadFullUrl?: string;
+    uploadParam?: string;
+    filekey: string;
+    cdnBaseUrl: string;
+    label: string;
+    aeskey: Buffer;
+}): Promise<{
+    downloadParam: string;
+}>;

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

@@ -0,0 +1,60 @@
+import { encryptAesEcb } from './aes_ecb.js';
+import { buildCdnUploadUrl } from './cdn_url.js';
+import { getIlinkRuntimeContext } from './context.js';
+import { redactUrl } from './redact.js';
+const UPLOAD_MAX_RETRIES = 3;
+export async function uploadBufferToCdn(params) {
+    const log = getIlinkRuntimeContext().logger;
+    const { buf, uploadFullUrl, uploadParam, filekey, cdnBaseUrl, label, aeskey } = params;
+    const ciphertext = encryptAesEcb(buf, aeskey);
+    const trimmedFull = uploadFullUrl?.trim();
+    let cdnUrl;
+    if (trimmedFull) {
+        cdnUrl = trimmedFull;
+    }
+    else if (uploadParam) {
+        cdnUrl = buildCdnUploadUrl({ cdnBaseUrl, uploadParam, filekey });
+    }
+    else {
+        throw new Error(`${label}: CDN upload URL missing (need upload_full_url or upload_param)`);
+    }
+    log.debug(`${label}: CDN POST url=${redactUrl(cdnUrl)} ciphertextSize=${ciphertext.length}`);
+    let downloadParam;
+    let lastError;
+    for (let attempt = 1; attempt <= UPLOAD_MAX_RETRIES; attempt++) {
+        try {
+            const res = await fetch(cdnUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/octet-stream' },
+                body: new Uint8Array(ciphertext),
+            });
+            if (res.status >= 400 && res.status < 500) {
+                const errMsg = res.headers.get('x-error-message') ?? (await res.text());
+                throw new Error(`CDN upload client error ${res.status}: ${errMsg}`);
+            }
+            if (res.status !== 200) {
+                const errMsg = res.headers.get('x-error-message') ?? `status ${res.status}`;
+                throw new Error(`CDN upload server error: ${errMsg}`);
+            }
+            downloadParam = res.headers.get('x-encrypted-param') ?? undefined;
+            if (!downloadParam) {
+                throw new Error('CDN upload response missing x-encrypted-param header');
+            }
+            break;
+        }
+        catch (err) {
+            lastError = err;
+            if (err instanceof Error && err.message.includes('client error'))
+                throw err;
+            if (attempt >= UPLOAD_MAX_RETRIES) {
+                log.error(`${label}: all ${UPLOAD_MAX_RETRIES} attempts failed err=${String(err)}`);
+            }
+        }
+    }
+    if (!downloadParam) {
+        throw lastError instanceof Error
+            ? lastError
+            : new Error(`CDN upload failed after ${UPLOAD_MAX_RETRIES} attempts`);
+    }
+    return { downloadParam };
+}

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

@@ -0,0 +1,7 @@
+export declare const ENABLE_CDN_URL_FALLBACK = true;
+export declare function buildCdnDownloadUrl(encryptedQueryParam: string, cdnBaseUrl: string): string;
+export declare function buildCdnUploadUrl(params: {
+    cdnBaseUrl: string;
+    uploadParam: string;
+    filekey: string;
+}): string;

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

@@ -0,0 +1,7 @@
+export const ENABLE_CDN_URL_FALLBACK = true;
+export function buildCdnDownloadUrl(encryptedQueryParam, cdnBaseUrl) {
+    return `${cdnBaseUrl}/download?encrypted_query_param=${encodeURIComponent(encryptedQueryParam)}`;
+}
+export function buildCdnUploadUrl(params) {
+    return `${params.cdnBaseUrl}/upload?encrypted_query_param=${encodeURIComponent(params.uploadParam)}&filekey=${encodeURIComponent(params.filekey)}`;
+}

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

@@ -0,0 +1,7 @@
+/** iLink app id (matches openclaw-weixin package.json ilink_appid). */
+export declare const ILINK_APP_ID = "bot";
+export declare const FIXED_QR_BASE_URL = "https://ilinkai.weixin.qq.com";
+export declare const DEFAULT_CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
+export declare const BRIDGE_PACKAGE_VERSION: string;
+export declare function buildClientVersion(version: string): number;
+export declare const ILINK_APP_CLIENT_VERSION: number;

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

@@ -0,0 +1,27 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** iLink app id (matches openclaw-weixin package.json ilink_appid). */
+export const ILINK_APP_ID = 'bot';
+export const FIXED_QR_BASE_URL = 'https://ilinkai.weixin.qq.com';
+export const DEFAULT_CDN_BASE_URL = 'https://novac2c.cdn.weixin.qq.com/c2c';
+function readBridgeVersion() {
+    try {
+        const dir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.resolve(dir, '../../../..', 'package.json');
+        const j = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return j.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export const BRIDGE_PACKAGE_VERSION = readBridgeVersion();
+export function buildClientVersion(version) {
+    const parts = version.split('.').map((p) => parseInt(p, 10));
+    const major = parts[0] ?? 0;
+    const minor = parts[1] ?? 0;
+    const patch = parts[2] ?? 0;
+    return ((major & 0xff) << 16) | ((minor & 0xff) << 8) | (patch & 0xff);
+}
+export const ILINK_APP_CLIENT_VERSION = buildClientVersion(BRIDGE_PACKAGE_VERSION);

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

@@ -0,0 +1,13 @@
+import type { Logger } from '../../../logger.js';
+export type IlinkLogger = Pick<Logger, 'debug' | 'info' | 'warn' | 'error'>;
+export interface IlinkRuntimeContext {
+    logger: IlinkLogger;
+    /** Optional routing tag for some IDC deployments. */
+    routeTag?: string;
+    channelVersion: string;
+    ilinkAppId: string;
+    ilinkAppClientVersion: number;
+}
+export declare function setIlinkRuntimeContext(next: IlinkRuntimeContext | null): void;
+export declare function getIlinkRuntimeContext(): IlinkRuntimeContext;
+export declare function tryGetIlinkRuntimeContext(): IlinkRuntimeContext | null;

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

@@ -0,0 +1,13 @@
+let ctx = null;
+export function setIlinkRuntimeContext(next) {
+    ctx = next;
+}
+export function getIlinkRuntimeContext() {
+    if (!ctx) {
+        throw new Error('Weixin iLink runtime not initialized (setIlinkRuntimeContext)');
+    }
+    return ctx;
+}
+export function tryGetIlinkRuntimeContext() {
+    return ctx;
+}

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

@@ -0,0 +1,34 @@
+export declare const DEFAULT_ILINK_BOT_TYPE = "3";
+export type WeixinQrStartResult = {
+    qrcodeUrl?: string;
+    message: string;
+    sessionKey: string;
+};
+export type WeixinQrWaitResult = {
+    connected: boolean;
+    botToken?: string;
+    accountId?: string;
+    baseUrl?: string;
+    userId?: string;
+    message: string;
+};
+export declare function startWeixinLoginWithQr(opts: {
+    verbose?: boolean;
+    timeoutMs?: number;
+    force?: boolean;
+    accountId?: string;
+    apiBaseUrl: string;
+    botType?: string;
+}): Promise<WeixinQrStartResult>;
+export type WeixinLoginNotify = (line: string) => void;
+export declare function waitForWeixinLogin(opts: {
+    timeoutMs?: number;
+    verbose?: boolean;
+    sessionKey: string;
+    apiBaseUrl: string;
+    botType?: string;
+    /** Optional user-facing lines (e.g. process.stdout.write). */
+    notify?: WeixinLoginNotify;
+    /** Called when QR was refreshed after expiry so CLI can re-render terminal QR. */
+    onQrRefreshed?: (qrcodeUrl: string) => void;
+}): Promise<WeixinQrWaitResult>;