@agent-spaces/server 0.1.0

package/dist/services/notification-hub/helpers.js

@@ -0,0 +1,72 @@
+import * as workspaceService from '../workspace.js';
+export function shouldNotify(workspaceId, event) {
+    const settings = workspaceService.getById(workspaceId)?.notificationSettings;
+    return Boolean(settings?.enabled && settings.events?.includes(event));
+}
+export function isIssueStartStatus(status) {
+    return status === 'planned' || status === 'in_progress';
+}
+export function isTaskDoneStatus(status) {
+    return status === 'done' || status === 'failed' || status === 'cancelled';
+}
+export function persistServiceRunning(workspaceId, serviceRunning) {
+    const workspace = workspaceService.getById(workspaceId);
+    const settings = workspace?.notificationSettings;
+    if (!workspace || !settings || settings.serviceRunning === serviceRunning)
+        return;
+    workspaceService.update(workspaceId, {
+        notificationSettings: {
+            ...settings,
+            serviceRunning,
+        },
+    });
+}
+export function persistLarkChatIds(workspaceId, chatIds) {
+    const workspace = workspaceService.getById(workspaceId);
+    const settings = workspace?.notificationSettings;
+    if (!workspace || !settings)
+        return;
+    workspaceService.update(workspaceId, {
+        notificationSettings: {
+            ...settings,
+            lark: {
+                ...settings.lark,
+                chatIds: [...new Set(chatIds)],
+            },
+        },
+    });
+}
+export function persistWeChatUserIds(workspaceId, userIds) {
+    const workspace = workspaceService.getById(workspaceId);
+    const settings = workspace?.notificationSettings;
+    if (!workspace || !settings)
+        return;
+    workspaceService.update(workspaceId, {
+        notificationSettings: {
+            ...settings,
+            wechat: {
+                ...settings.wechat,
+                userIds: [...new Set(userIds)],
+            },
+        },
+    });
+}
+export function persistWeChatGetUpdatesBuf(workspaceId, getUpdatesBuf) {
+    const workspace = workspaceService.getById(workspaceId);
+    const settings = workspace?.notificationSettings;
+    if (!workspace || !settings)
+        return;
+    workspaceService.update(workspaceId, {
+        notificationSettings: {
+            ...settings,
+            wechat: {
+                ...settings.wechat,
+                getUpdatesBuf,
+            },
+        },
+    });
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=helpers.js.map

package/dist/services/notification-hub/index.js

@@ -0,0 +1,7 @@
+// Service lifecycle
+export { startWorkspaceNotificationService, stopWorkspaceNotificationService, startPersistedNotificationServices, sendTestNotification } from './service.js';
+// Event publishing
+export { publishWorkspaceEvent } from './events.js';
+// WeChat login
+export { getWeChatLoginQRCode, pollWeChatLoginStatus } from './wechat-api.js';
+//# sourceMappingURL=index.js.map

package/dist/services/notification-hub/lark-adapter.js

@@ -0,0 +1,110 @@
+import * as Lark from '@larksuiteoapi/node-sdk';
+import { larkChatIdsByWorkspace } from './types.js';
+import { formatLarkTitle, formatLarkContent } from './format.js';
+import { persistLarkChatIds } from './helpers.js';
+import { isDuplicateLarkMessage, parseLarkText } from './lark-api.js';
+import { isBuiltInCommand, buildCommandResponse } from './bot-commands.js';
+import { getConfiguredBotAgent, runBotAgent } from './bot-agent.js';
+export class LarkNotificationAdapter {
+    workspace;
+    client;
+    wsClient;
+    started = false;
+    constructor(workspace, settings) {
+        this.workspace = workspace;
+        const appId = settings.lark?.appId?.trim();
+        const appSecret = settings.lark?.appSecret?.trim();
+        if (!appId || !appSecret) {
+            throw new Error('Lark app_id and app_secret are required');
+        }
+        const baseConfig = { appId, appSecret };
+        this.client = new Lark.Client(baseConfig);
+        this.wsClient = new Lark.WSClient({ ...baseConfig, loggerLevel: Lark.LoggerLevel.info });
+        if (settings.lark?.chatIds?.length) {
+            larkChatIdsByWorkspace.set(workspace.id, new Set(settings.lark.chatIds));
+        }
+    }
+    async start() {
+        this.wsClient.start({
+            eventDispatcher: new Lark.EventDispatcher({}).register({
+                'im.message.receive_v1': async (data) => this.handleMessage(data),
+            }),
+        });
+        this.started = true;
+    }
+    async stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        this.wsClient.close({ force: true });
+    }
+    async send(envelope) {
+        const chatIds = larkChatIdsByWorkspace.get(this.workspace.id);
+        if (!chatIds?.size)
+            return;
+        for (const chatId of chatIds) {
+            await this.client.im.v1.message.create({
+                params: { receive_id_type: 'chat_id' },
+                data: {
+                    receive_id: chatId,
+                    content: Lark.messageCard.defaultCard({
+                        title: formatLarkTitle(envelope),
+                        content: formatLarkContent(envelope),
+                    }),
+                    msg_type: 'interactive',
+                },
+            });
+        }
+    }
+    hasRecipients() {
+        return Boolean(larkChatIdsByWorkspace.get(this.workspace.id)?.size);
+    }
+    async handleMessage(data) {
+        const chatId = data.message?.chat_id;
+        if (!chatId)
+            return;
+        if (isDuplicateLarkMessage(this.workspace.id, data))
+            return;
+        if (data.sender?.sender_type && data.sender.sender_type !== 'user')
+            return;
+        if (data.message?.message_type && data.message.message_type !== 'text')
+            return;
+        const chatIds = larkChatIdsByWorkspace.get(this.workspace.id) ?? new Set();
+        chatIds.add(chatId);
+        larkChatIdsByWorkspace.set(this.workspace.id, chatIds);
+        persistLarkChatIds(this.workspace.id, Array.from(chatIds));
+        const text = parseLarkText(data.message?.content);
+        if (!text)
+            return;
+        if (isBuiltInCommand(text)) {
+            await this.sendCard(chatId, 'Agent Spaces', await buildCommandResponse({
+                defaultWorkspaceId: this.workspace.id,
+                conversationId: `lark:${chatId}`,
+                text,
+            }));
+            return;
+        }
+        const botAgent = getConfiguredBotAgent(this.workspace.id);
+        if (!botAgent) {
+            await this.sendCard(chatId, 'Agent Spaces', '请先设置agent');
+            return;
+        }
+        await this.sendCard(chatId, 'Agent Spaces', `${botAgent.name} working...`);
+        const reply = await runBotAgent(this.workspace.id, botAgent, text);
+        await this.sendCard(chatId, botAgent.name, reply);
+    }
+    async sendCard(chatId, title, content) {
+        await this.client.im.v1.message.create({
+            params: { receive_id_type: 'chat_id' },
+            data: {
+                receive_id: chatId,
+                content: Lark.messageCard.defaultCard({
+                    title,
+                    content,
+                }),
+                msg_type: 'interactive',
+            },
+        });
+    }
+}
+//# sourceMappingURL=lark-adapter.js.map

package/dist/services/notification-hub/lark-api.js

@@ -0,0 +1,40 @@
+import { recentLarkMessageIdsByWorkspace, LARK_MESSAGE_DEDUPE_TTL_MS, } from './types.js';
+export function isDuplicateLarkMessage(workspaceId, data) {
+    const id = data.message?.message_id
+        ?? buildFallbackLarkMessageId(data)
+        ?? data.header?.event_id
+        ?? data.event_id;
+    if (!id)
+        return false;
+    const now = Date.now();
+    const seen = recentLarkMessageIdsByWorkspace.get(workspaceId) ?? new Map();
+    for (const [key, timestamp] of seen) {
+        if (now - timestamp > LARK_MESSAGE_DEDUPE_TTL_MS)
+            seen.delete(key);
+    }
+    recentLarkMessageIdsByWorkspace.set(workspaceId, seen);
+    if (seen.has(id))
+        return true;
+    seen.set(id, now);
+    return false;
+}
+function buildFallbackLarkMessageId(data) {
+    const chatId = data.message?.chat_id;
+    const content = data.message?.content;
+    const createTime = data.message?.create_time;
+    if (!chatId || !content)
+        return undefined;
+    return `${chatId}:${createTime ?? ''}:${content}`;
+}
+export function parseLarkText(content) {
+    if (!content)
+        return '';
+    try {
+        const parsed = JSON.parse(content);
+        return parsed.text?.trim() ?? '';
+    }
+    catch {
+        return content.trim();
+    }
+}
+//# sourceMappingURL=lark-api.js.map

package/dist/services/notification-hub/service.js

@@ -0,0 +1,80 @@
+import * as workspaceService from '../workspace.js';
+import { adapters } from './types.js';
+import { persistServiceRunning } from './helpers.js';
+import { WeChatNotificationAdapter } from './wechat-adapter.js';
+import { LarkNotificationAdapter } from './lark-adapter.js';
+export async function startWorkspaceNotificationService(workspaceId) {
+    const workspace = workspaceService.getById(workspaceId);
+    const settings = workspace?.notificationSettings;
+    if (!workspace || !settings?.enabled)
+        return { started: false };
+    await stopWorkspaceNotificationService(workspaceId);
+    if (settings.provider === 'lark') {
+        const adapter = new LarkNotificationAdapter(workspace, settings);
+        await adapter.start();
+        adapters.set(workspaceId, adapter);
+        persistServiceRunning(workspaceId, true);
+        return { started: true, provider: 'lark' };
+    }
+    if (settings.provider === 'wechat') {
+        const adapter = new WeChatNotificationAdapter(workspace, settings);
+        await adapter.start();
+        adapters.set(workspaceId, adapter);
+        persistServiceRunning(workspaceId, true);
+        return { started: true, provider: 'wechat' };
+    }
+    return { started: false, provider: settings.provider };
+}
+export async function stopWorkspaceNotificationService(workspaceId) {
+    const adapter = adapters.get(workspaceId);
+    if (adapter) {
+        adapters.delete(workspaceId);
+        await adapter.stop();
+    }
+    persistServiceRunning(workspaceId, false);
+}
+export async function startPersistedNotificationServices() {
+    for (const workspace of workspaceService.getAll()) {
+        const settings = workspace.notificationSettings;
+        if (!settings?.enabled || !settings.serviceRunning)
+            continue;
+        try {
+            await startWorkspaceNotificationService(workspace.id);
+            console.log(`[notification] restored ${settings.provider} service workspaceId=${workspace.id}`);
+        }
+        catch (err) {
+            console.error(`[notification] failed to restore service workspaceId=${workspace.id}:`, err);
+        }
+    }
+}
+export async function sendTestNotification(workspaceId) {
+    const workspace = workspaceService.getById(workspaceId);
+    if (!workspace?.notificationSettings?.enabled) {
+        return { sent: false, reason: 'Notification service is not enabled' };
+    }
+    let adapter = adapters.get(workspaceId);
+    if (!adapter) {
+        const started = await startWorkspaceNotificationService(workspaceId);
+        if (!started.started)
+            return { sent: false, reason: 'Notification service is not running' };
+        adapter = adapters.get(workspaceId);
+    }
+    if (!adapter)
+        return { sent: false, reason: 'Notification adapter is unavailable' };
+    if (!adapter.hasRecipients()) {
+        const provider = workspace.notificationSettings.provider === 'wechat' ? 'WeChat user' : 'Feishu chat';
+        return { sent: false, reason: `No ${provider} is registered yet. Send any message to the bot first.` };
+    }
+    await adapter.send({
+        event: 'issue_status_change',
+        workspaceId,
+        timestamp: new Date().toISOString(),
+        data: {
+            title: 'Notification test',
+            status: 'test',
+            message: 'Agent Spaces notification service is connected.',
+        },
+    });
+    return { sent: true };
+}
+//# sourceMappingURL=service.js.map

package/dist/services/notification-hub/types.js

@@ -0,0 +1,31 @@
+export const WeChatMessageType = {
+    USER: 1,
+    BOT: 2,
+};
+export const WeChatMessageItemType = {
+    TEXT: 1,
+};
+export const WeChatMessageState = {
+    FINISH: 2,
+};
+// Shared state
+export const adapters = new Map();
+export const larkChatIdsByWorkspace = new Map();
+export const recentLarkMessageIdsByWorkspace = new Map();
+export const botCommandContexts = new Map();
+export const recentWechatMessageIdsByWorkspace = new Map();
+export const wechatUserIdsByWorkspace = new Map();
+export const wechatContextTokensByWorkspace = new Map();
+export const wechatLoginSessions = new Map();
+// Constants
+export const LARK_MESSAGE_DEDUPE_TTL_MS = 5 * 60 * 1000;
+export const WECHAT_BASE_URL = 'https://ilinkai.weixin.qq.com';
+export const WECHAT_BOT_TYPE = '3';
+export const WECHAT_API_TIMEOUT_MS = 15_000;
+export const WECHAT_QR_STATUS_TIMEOUT_MS = 8_000;
+export const WECHAT_LONG_POLL_TIMEOUT_MS = 35_000;
+export const WECHAT_RETRY_DELAY_MS = 2_000;
+export const WECHAT_BACKOFF_DELAY_MS = 30_000;
+export const WECHAT_MAX_CONSECUTIVE_FAILURES = 5;
+export const WECHAT_MESSAGE_DEDUPE_TTL_MS = 5 * 60 * 1000;
+//# sourceMappingURL=types.js.map

package/dist/services/notification-hub/wechat-adapter.js

@@ -0,0 +1,126 @@
+import { WECHAT_BASE_URL, WECHAT_BACKOFF_DELAY_MS, WECHAT_MAX_CONSECUTIVE_FAILURES, WECHAT_RETRY_DELAY_MS, WeChatMessageType, wechatUserIdsByWorkspace, } from './types.js';
+import { formatLarkTitle, formatLarkContent } from './format.js';
+import { persistWeChatUserIds, persistWeChatGetUpdatesBuf, sleep } from './helpers.js';
+import { getWeChatUpdates, sendWeChatTextMessage, extractWeChatTextFromMessage, isDuplicateWeChatMessage, getWeChatContextToken, setWeChatContextToken, } from './wechat-api.js';
+import { isBuiltInCommand, buildCommandResponse } from './bot-commands.js';
+import { getConfiguredBotAgent, runBotAgent } from './bot-agent.js';
+export class WeChatNotificationAdapter {
+    workspace;
+    running = false;
+    credentials;
+    getUpdatesBuf = '';
+    constructor(workspace, settings) {
+        this.workspace = workspace;
+        const token = settings.wechat?.token?.trim();
+        const baseUrl = settings.wechat?.baseUrl?.trim() || WECHAT_BASE_URL;
+        const accountId = settings.wechat?.accountId?.trim();
+        if (!token || !accountId) {
+            throw new Error('WeChat login is required. Scan the QR code first.');
+        }
+        this.credentials = {
+            token,
+            baseUrl,
+            accountId,
+            userId: settings.wechat?.userId,
+        };
+        this.getUpdatesBuf = settings.wechat?.getUpdatesBuf ?? '';
+        if (settings.wechat?.userIds?.length) {
+            wechatUserIdsByWorkspace.set(workspace.id, new Set(settings.wechat.userIds));
+        }
+    }
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        void this.pollLoop();
+    }
+    async stop() {
+        this.running = false;
+    }
+    async send(envelope) {
+        const userIds = wechatUserIdsByWorkspace.get(this.workspace.id);
+        if (!userIds?.size)
+            return;
+        const text = [
+            formatLarkTitle(envelope),
+            '',
+            formatLarkContent(envelope),
+        ].filter(Boolean).join('\n');
+        for (const userId of userIds) {
+            await sendWeChatTextMessage(this.credentials.baseUrl, this.credentials.token, userId, text, getWeChatContextToken(this.workspace.id, userId));
+        }
+    }
+    hasRecipients() {
+        return Boolean(wechatUserIdsByWorkspace.get(this.workspace.id)?.size);
+    }
+    async pollLoop() {
+        let failures = 0;
+        while (this.running) {
+            try {
+                const resp = await getWeChatUpdates(this.credentials.baseUrl, this.credentials.token, this.getUpdatesBuf);
+                if (resp.ret !== undefined && resp.ret !== 0) {
+                    failures++;
+                    console.error(`[notification] WeChat getupdates failed workspaceId=${this.workspace.id} ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg}`);
+                    await sleep(failures >= WECHAT_MAX_CONSECUTIVE_FAILURES ? WECHAT_BACKOFF_DELAY_MS : WECHAT_RETRY_DELAY_MS);
+                    if (failures >= WECHAT_MAX_CONSECUTIVE_FAILURES)
+                        failures = 0;
+                    continue;
+                }
+                failures = 0;
+                if (resp.get_updates_buf && resp.get_updates_buf !== this.getUpdatesBuf) {
+                    this.getUpdatesBuf = resp.get_updates_buf;
+                    persistWeChatGetUpdatesBuf(this.workspace.id, this.getUpdatesBuf);
+                }
+                for (const msg of resp.msgs ?? []) {
+                    await this.handleMessage(msg);
+                }
+            }
+            catch (err) {
+                failures++;
+                console.error(`[notification] WeChat polling error workspaceId=${this.workspace.id}:`, err);
+                await sleep(failures >= WECHAT_MAX_CONSECUTIVE_FAILURES ? WECHAT_BACKOFF_DELAY_MS : WECHAT_RETRY_DELAY_MS);
+                if (failures >= WECHAT_MAX_CONSECUTIVE_FAILURES)
+                    failures = 0;
+            }
+        }
+    }
+    async handleMessage(msg) {
+        if (msg.message_type !== WeChatMessageType.USER)
+            return;
+        if (isDuplicateWeChatMessage(this.workspace.id, msg))
+            return;
+        const fromUser = msg.from_user_id;
+        if (!fromUser)
+            return;
+        const userIds = wechatUserIdsByWorkspace.get(this.workspace.id) ?? new Set();
+        userIds.add(fromUser);
+        wechatUserIdsByWorkspace.set(this.workspace.id, userIds);
+        persistWeChatUserIds(this.workspace.id, Array.from(userIds));
+        if (msg.context_token) {
+            setWeChatContextToken(this.workspace.id, fromUser, msg.context_token);
+        }
+        const text = extractWeChatTextFromMessage(msg).trim();
+        if (!text)
+            return;
+        if (isBuiltInCommand(text)) {
+            await this.reply(fromUser, await buildCommandResponse({
+                defaultWorkspaceId: this.workspace.id,
+                conversationId: `wechat:${fromUser}`,
+                text,
+            }));
+            return;
+        }
+        const botAgent = getConfiguredBotAgent(this.workspace.id);
+        if (!botAgent) {
+            await this.reply(fromUser, '请先设置agent');
+            return;
+        }
+        await this.reply(fromUser, `${botAgent.name} working...`);
+        const reply = await runBotAgent(this.workspace.id, botAgent, text);
+        await this.reply(fromUser, reply);
+    }
+    async reply(to, text) {
+        await sendWeChatTextMessage(this.credentials.baseUrl, this.credentials.token, to, text, getWeChatContextToken(this.workspace.id, to));
+    }
+}
+//# sourceMappingURL=wechat-adapter.js.map

package/dist/services/notification-hub/wechat-api.js

@@ -0,0 +1,212 @@
+import crypto from 'node:crypto';
+import * as workspaceService from '../workspace.js';
+import { WeChatMessageItemType, WeChatMessageState, WeChatMessageType, WECHAT_API_TIMEOUT_MS, WECHAT_BASE_URL, WECHAT_BOT_TYPE, WECHAT_LONG_POLL_TIMEOUT_MS, WECHAT_MESSAGE_DEDUPE_TTL_MS, WECHAT_QR_STATUS_TIMEOUT_MS, wechatContextTokensByWorkspace, wechatLoginSessions, recentWechatMessageIdsByWorkspace, } from './types.js';
+// --- WeChat Login ---
+export async function getWeChatLoginQRCode(workspaceId, forceRefresh = false) {
+    const workspace = workspaceService.getById(workspaceId);
+    if (!workspace)
+        throw new Error('Workspace not found');
+    const settings = workspace.notificationSettings;
+    if (!forceRefresh && settings?.wechat?.token && settings.wechat.accountId) {
+        return {
+            status: 'confirmed',
+            accountId: settings.wechat.accountId,
+            userId: settings.wechat.userId,
+            baseUrl: settings.wechat.baseUrl,
+            workspace,
+        };
+    }
+    if (forceRefresh)
+        wechatLoginSessions.delete(workspaceId);
+    const existing = wechatLoginSessions.get(workspaceId);
+    if (existing && Date.now() - existing.createdAt < 2 * 60_000) {
+        return {
+            status: 'wait',
+            qrcode: existing.qrcode,
+            qrcodeImgContent: existing.qrcodeImgContent,
+        };
+    }
+    const qr = await fetchWeChatQRCode();
+    wechatLoginSessions.set(workspaceId, {
+        qrcode: qr.qrcode,
+        qrcodeImgContent: qr.qrcode_img_content,
+        createdAt: Date.now(),
+    });
+    return {
+        status: 'wait',
+        qrcode: qr.qrcode,
+        qrcodeImgContent: qr.qrcode_img_content,
+    };
+}
+export async function pollWeChatLoginStatus(workspaceId) {
+    const session = wechatLoginSessions.get(workspaceId);
+    if (!session)
+        return getWeChatLoginQRCode(workspaceId);
+    const status = await fetchWeChatQRCodeStatus(session.qrcode);
+    if (status.status === 'confirmed') {
+        if (!status.bot_token || !status.ilink_bot_id) {
+            throw new Error('WeChat login confirmed but token or bot id is missing');
+        }
+        const workspace = workspaceService.getById(workspaceId);
+        const settings = workspace?.notificationSettings ?? {
+            enabled: true,
+            provider: 'wechat',
+            events: ['issue_started', 'issue_completed', 'issue_task_completed'],
+        };
+        const baseUrl = status.baseurl || WECHAT_BASE_URL;
+        const updated = workspaceService.update(workspaceId, {
+            notificationSettings: {
+                ...settings,
+                provider: 'wechat',
+                wechat: {
+                    ...settings.wechat,
+                    token: status.bot_token,
+                    baseUrl,
+                    accountId: status.ilink_bot_id,
+                    userId: status.ilink_user_id,
+                },
+            },
+        });
+        wechatLoginSessions.delete(workspaceId);
+        return {
+            status: 'confirmed',
+            accountId: updated?.notificationSettings?.wechat?.accountId,
+            userId: updated?.notificationSettings?.wechat?.userId,
+            baseUrl: updated?.notificationSettings?.wechat?.baseUrl,
+            workspace: updated ?? undefined,
+        };
+    }
+    if (status.status === 'expired') {
+        wechatLoginSessions.delete(workspaceId);
+    }
+    return {
+        status: status.status,
+        qrcode: session.qrcode,
+        qrcodeImgContent: session.qrcodeImgContent,
+    };
+}
+// --- WeChat HTTP API ---
+async function fetchWeChatQRCode() {
+    const res = await fetch(`${WECHAT_BASE_URL}/ilink/bot/get_bot_qrcode?bot_type=${WECHAT_BOT_TYPE}`);
+    if (!res.ok)
+        throw new Error(`Failed to get WeChat QR code: ${res.status}`);
+    return await res.json();
+}
+async function fetchWeChatQRCodeStatus(qrcode) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), WECHAT_QR_STATUS_TIMEOUT_MS);
+    try {
+        const res = await fetch(`${WECHAT_BASE_URL}/ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`, {
+            headers: { 'iLink-App-ClientVersion': '1' },
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (!res.ok)
+            throw new Error(`Failed to poll WeChat QR code status: ${res.status}`);
+        return await res.json();
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === 'AbortError')
+            return { status: 'wait' };
+        throw err;
+    }
+}
+function randomWechatUin() {
+    const uint32 = crypto.randomBytes(4).readUInt32BE(0);
+    return Buffer.from(String(uint32), 'utf-8').toString('base64');
+}
+function buildWeChatHeaders(token) {
+    const headers = {
+        'Content-Type': 'application/json',
+        AuthorizationType: 'ilink_bot_token',
+        'X-WECHAT-UIN': randomWechatUin(),
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+}
+async function postWeChatApi(baseUrl, endpoint, body, token, timeoutMs = WECHAT_API_TIMEOUT_MS) {
+    const url = new URL(endpoint, baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
+    const bodyStr = JSON.stringify(body);
+    const headers = buildWeChatHeaders(token);
+    headers['Content-Length'] = String(Buffer.byteLength(bodyStr, 'utf-8'));
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url.toString(), {
+            method: 'POST',
+            headers,
+            body: bodyStr,
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        const text = await res.text();
+        if (!res.ok)
+            throw new Error(`WeChat API ${endpoint} responded ${res.status}: ${text}`);
+        return JSON.parse(text);
+    }
+    catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === 'AbortError' && endpoint === 'ilink/bot/getupdates') {
+            return { ret: 0, msgs: [], get_updates_buf: body.get_updates_buf ?? '' };
+        }
+        throw err;
+    }
+}
+export async function getWeChatUpdates(baseUrl, token, buf) {
+    return postWeChatApi(baseUrl, 'ilink/bot/getupdates', { get_updates_buf: buf }, token, WECHAT_LONG_POLL_TIMEOUT_MS);
+}
+export async function sendWeChatTextMessage(baseUrl, token, to, text, contextToken) {
+    const clientId = `bot-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await postWeChatApi(baseUrl, 'ilink/bot/sendmessage', {
+        msg: {
+            from_user_id: '',
+            to_user_id: to,
+            client_id: clientId,
+            message_type: WeChatMessageType.BOT,
+            message_state: WeChatMessageState.FINISH,
+            item_list: text
+                ? [{ type: WeChatMessageItemType.TEXT, text_item: { text } }]
+                : undefined,
+            context_token: contextToken,
+        },
+    }, token);
+}
+// --- WeChat Message Helpers ---
+export function extractWeChatTextFromMessage(msg) {
+    for (const item of msg.item_list ?? []) {
+        if (item.type !== WeChatMessageItemType.TEXT || !item.text_item?.text)
+            continue;
+        const refTitle = item.ref_msg?.title;
+        return refTitle ? `[引用: ${refTitle}]\n${item.text_item.text}` : item.text_item.text;
+    }
+    return '';
+}
+export function isDuplicateWeChatMessage(workspaceId, msg) {
+    const id = msg.message_id
+        ? String(msg.message_id)
+        : `${msg.from_user_id ?? ''}:${msg.create_time_ms ?? ''}:${extractWeChatTextFromMessage(msg)}`;
+    if (!id.replace(/:/g, ''))
+        return false;
+    const now = Date.now();
+    const seen = recentWechatMessageIdsByWorkspace.get(workspaceId) ?? new Map();
+    for (const [key, timestamp] of seen) {
+        if (now - timestamp > WECHAT_MESSAGE_DEDUPE_TTL_MS)
+            seen.delete(key);
+    }
+    recentWechatMessageIdsByWorkspace.set(workspaceId, seen);
+    if (seen.has(id))
+        return true;
+    seen.set(id, now);
+    return false;
+}
+export function getWeChatContextToken(workspaceId, userId) {
+    return wechatContextTokensByWorkspace.get(workspaceId)?.get(userId);
+}
+export function setWeChatContextToken(workspaceId, userId, contextToken) {
+    const tokens = wechatContextTokensByWorkspace.get(workspaceId) ?? new Map();
+    tokens.set(userId, contextToken);
+    wechatContextTokensByWorkspace.set(workspaceId, tokens);
+}
+//# sourceMappingURL=wechat-api.js.map