evolcore 0.0.1 → 0.0.3

package/dist/channels/wecom-card.js

@@ -0,0 +1,101 @@
+function truncate(value, max) {
+    if (!value)
+        return undefined;
+    const chars = [...value.trim()];
+    return chars.length <= max ? value.trim() : `${chars.slice(0, Math.max(1, max - 1)).join('')}...`;
+}
+function buttonStyle(style) {
+    if (style === 'primary')
+        return 2;
+    if (style === 'danger')
+        return 3;
+    return 1;
+}
+export function buildWecomInteractionCard(interaction, taskId) {
+    const bodyParts = [];
+    if (interaction.kind.body)
+        bodyParts.push(interaction.kind.body);
+    if (interaction.kind.kind === 'action' && interaction.kind.checkers?.length) {
+        bodyParts.push(interaction.kind.checkers.map((item, index) => `${index + 1}. ${item.label}`).join('\n'));
+    }
+    return {
+        card_type: 'button_interaction',
+        task_id: taskId,
+        main_title: {
+            title: truncate(interaction.kind.title, 26),
+            desc: truncate(bodyParts.join('\n\n'), 120),
+        },
+        button_list: interaction.kind.buttons
+            .map((button, index) => ({ button, index }))
+            .filter(({ button }) => !('disabled' in button) || !button.disabled)
+            .slice(0, 6)
+            .map(({ button, index }) => ({
+            text: truncate(button.label, 10) || `选项 ${index + 1}`,
+            style: buttonStyle(button.style),
+            key: interaction.kind.kind === 'command-card' ? `cmd_${index}` : `act_${index}`,
+        })),
+    };
+}
+export function parseWecomCardResponse(record, event, operatorId) {
+    const eventKey = String(event.event_key ?? '').trim();
+    const match = /^(cmd|act)_(\d+)$/.exec(eventKey);
+    if (!match)
+        return null;
+    const index = Number(match[2]);
+    if (record.interaction.kind.kind === 'command-card') {
+        const button = record.interaction.kind.buttons[index];
+        if (!button || button.disabled)
+            return null;
+        return { command: button.command };
+    }
+    const button = record.interaction.kind.buttons[index];
+    if (!button)
+        return null;
+    const values = {};
+    const selectedItems = event.selected_items?.selected_item;
+    if (Array.isArray(selectedItems)) {
+        for (const selected of selectedItems) {
+            const questionKey = String(selected?.question_key ?? '').trim();
+            const optionIds = selected?.option_ids?.option_id;
+            if (questionKey && Array.isArray(optionIds))
+                values[questionKey] = optionIds.filter(Boolean);
+        }
+    }
+    return {
+        response: {
+            type: 'interaction.response',
+            id: record.interaction.id,
+            action: button.key,
+            values: Object.keys(values).length > 0 ? values : undefined,
+            operatorId,
+        },
+    };
+}
+export function buildWecomTerminalCard(record, status, detail) {
+    const statusText = status === 'resolved'
+        ? `已处理${detail ? `：${detail}` : ''}`
+        : status === 'rejected'
+            ? '仅卡片发起者可操作'
+            : status === 'unavailable'
+                ? '处理服务暂不可用，请重新发起'
+                : `卡片已失效${detail ? `：${detail}` : ''}`;
+    return {
+        card_type: 'text_notice',
+        task_id: record.taskId,
+        main_title: {
+            title: truncate(record.interaction.kind.title, 26),
+            desc: truncate(statusText, 120),
+        },
+        sub_title_text: truncate(record.interaction.kind.body, 120),
+    };
+}
+export function buildWecomUnknownCard(taskId) {
+    return {
+        card_type: 'text_notice',
+        task_id: taskId,
+        main_title: {
+            title: '卡片已失效',
+            desc: '本地状态不存在，请重新发起操作',
+        },
+    };
+}

package/dist/channels/wecom-onboarding.js

@@ -0,0 +1,82 @@
+import os from 'node:os';
+const WECOM_QR_GENERATE_URL = 'https://work.weixin.qq.com/ai/qc/generate';
+const WECOM_QR_QUERY_URL = 'https://work.weixin.qq.com/ai/qc/query_result';
+const WECOM_QR_PAGE_URL = 'https://work.weixin.qq.com/ai/qc/gen';
+function platformCode() {
+    if (os.platform() === 'darwin')
+        return 1;
+    if (os.platform() === 'win32')
+        return 2;
+    if (os.platform() === 'linux')
+        return 3;
+    return 0;
+}
+async function fetchJson(url, fetchImpl, signal) {
+    const timeoutSignal = AbortSignal.timeout(15_000);
+    const response = await fetchImpl(url, {
+        headers: { Accept: 'application/json' },
+        signal: signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal,
+    });
+    if (!response.ok)
+        throw new Error(`企微扫码服务请求失败: HTTP ${response.status}`);
+    return response.json();
+}
+export async function createWecomQrSession(fetchImpl = fetch) {
+    const url = new URL(WECOM_QR_GENERATE_URL);
+    url.searchParams.set('source', 'wecom-cli');
+    url.searchParams.set('plat', String(platformCode()));
+    const payload = await fetchJson(url, fetchImpl);
+    const scode = String(payload?.data?.scode ?? '').trim();
+    const authUrl = String(payload?.data?.auth_url ?? '').trim();
+    if (!scode || !authUrl)
+        throw new Error('企微扫码服务未返回 scode 或授权地址');
+    const browserUrl = new URL(WECOM_QR_PAGE_URL);
+    browserUrl.searchParams.set('source', 'wecom-cli');
+    browserUrl.searchParams.set('scode', scode);
+    return { scode, authUrl, browserUrl: browserUrl.toString() };
+}
+export async function pollWecomQrCredentials(scode, opts) {
+    const fetchImpl = opts?.fetchImpl ?? fetch;
+    const timeoutMs = opts?.timeoutMs ?? 5 * 60 * 1000;
+    const intervalMs = opts?.intervalMs ?? 3_000;
+    const deadline = Date.now() + timeoutMs;
+    const url = new URL(WECOM_QR_QUERY_URL);
+    url.searchParams.set('scode', scode);
+    let previousStatus = '';
+    while (Date.now() < deadline) {
+        if (opts?.signal?.aborted)
+            throw new Error('企微扫码已取消');
+        const payload = await fetchJson(url, fetchImpl, opts?.signal);
+        const status = String(payload?.data?.status ?? 'waiting');
+        if (status !== previousStatus) {
+            opts?.onStatus?.(status);
+            previousStatus = status;
+        }
+        if (status === 'success') {
+            const botId = String(payload?.data?.bot_info?.botid ?? '').trim();
+            const secret = String(payload?.data?.bot_info?.secret ?? '').trim();
+            if (!botId || !secret)
+                throw new Error('扫码成功，但企微未返回 Bot ID 或 Secret');
+            return { botId, secret };
+        }
+        if (status === 'expired' || status === 'cancelled' || status === 'rejected') {
+            throw new Error(`企微扫码未完成: ${status}`);
+        }
+        await new Promise((resolve, reject) => {
+            const finish = () => {
+                opts?.signal?.removeEventListener('abort', onAbort);
+                resolve();
+            };
+            const timer = setTimeout(finish, intervalMs);
+            const onAbort = () => {
+                clearTimeout(timer);
+                opts?.signal?.removeEventListener('abort', onAbort);
+                reject(new Error('企微扫码已取消'));
+            };
+            opts?.signal?.addEventListener('abort', onAbort, { once: true });
+            if (opts?.signal?.aborted)
+                onAbort();
+        });
+    }
+    throw new Error('企微扫码超时，请重新生成二维码');
+}

package/dist/channels/wecom-state.js

@@ -0,0 +1,191 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { agentDataDir } from '../paths.js';
+import { atomicReadJson, atomicWriteJson } from '../utils/atomic-write.js';
+import { logger } from '../utils/logger.js';
+const STORE_VERSION = 1;
+const DEFAULT_DEDUP_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_CARD_RETENTION_MS = 24 * 60 * 60 * 1000;
+function writePrivateJson(filePath, value) {
+    atomicWriteJson(filePath, value);
+    try {
+        fs.chmodSync(filePath, 0o600);
+    }
+    catch { /* best effort on non-POSIX filesystems */ }
+}
+export class PersistentWecomDeduper {
+    filePath;
+    channelKey;
+    entries = new Map();
+    ttlMs;
+    maxEntries;
+    constructor(filePath, channelKey, opts) {
+        this.filePath = filePath;
+        this.channelKey = channelKey;
+        this.ttlMs = opts?.ttlMs ?? DEFAULT_DEDUP_TTL_MS;
+        this.maxEntries = opts?.maxEntries ?? 20_000;
+        this.load();
+    }
+    checkAndMark(messageId, now = Date.now()) {
+        this.evict(now);
+        const seenAt = this.entries.get(messageId);
+        if (seenAt !== undefined && now - seenAt <= this.ttlMs)
+            return true;
+        this.entries.set(messageId, now);
+        this.trimToLimit();
+        this.flush();
+        return false;
+    }
+    get size() {
+        return this.entries.size;
+    }
+    load() {
+        if (!this.filePath)
+            return;
+        try {
+            const stored = atomicReadJson(this.filePath);
+            if (!stored || stored.version !== STORE_VERSION || stored.channelKey !== this.channelKey)
+                return;
+            for (const [id, timestamp] of Object.entries(stored.entries ?? {})) {
+                if (id && Number.isFinite(timestamp))
+                    this.entries.set(id, timestamp);
+            }
+            const before = this.entries.size;
+            this.evict(Date.now());
+            this.trimToLimit();
+            if (this.entries.size !== before)
+                this.flush();
+        }
+        catch (error) {
+            logger.warn(`[WeCom] Ignoring unreadable dedup store for ${this.channelKey}: ${String(error)}`);
+            this.entries.clear();
+        }
+    }
+    evict(now) {
+        for (const [id, timestamp] of this.entries) {
+            if (now - timestamp > this.ttlMs)
+                this.entries.delete(id);
+        }
+    }
+    trimToLimit() {
+        if (this.entries.size <= this.maxEntries)
+            return;
+        const oldest = [...this.entries.entries()].sort((a, b) => a[1] - b[1]);
+        for (let i = 0; i < oldest.length - this.maxEntries; i++) {
+            this.entries.delete(oldest[i][0]);
+        }
+    }
+    flush() {
+        writePrivateJson(this.filePath, {
+            version: STORE_VERSION,
+            channelKey: this.channelKey,
+            entries: Object.fromEntries(this.entries),
+        });
+    }
+}
+export class PersistentWecomCardStore {
+    filePath;
+    channelKey;
+    records = new Map();
+    constructor(filePath, channelKey) {
+        this.filePath = filePath;
+        this.channelKey = channelKey;
+        if (filePath)
+            this.load();
+    }
+    set(record) {
+        this.records.set(record.taskId, record);
+        this.cleanup();
+        this.flush();
+    }
+    get(taskId) {
+        this.cleanup();
+        return this.records.get(taskId);
+    }
+    findByInteractionId(interactionId) {
+        this.cleanup();
+        return [...this.records.values()].find(record => record.interaction.id === interactionId);
+    }
+    listPendingByChat(chatId) {
+        this.cleanup();
+        return [...this.records.values()].filter(record => (record.chatId === chatId
+            && record.status === 'pending'
+            && (!record.expiresAt || record.expiresAt >= Date.now())));
+    }
+    resolve(taskId, action) {
+        const record = this.records.get(taskId);
+        if (!record)
+            return undefined;
+        record.status = 'resolved';
+        record.resolution = action;
+        record.updatedAt = Date.now();
+        this.flush();
+        return record;
+    }
+    invalidateByInteractionId(interactionId, reason) {
+        const record = this.findByInteractionId(interactionId);
+        if (!record || record.status === 'resolved')
+            return record;
+        record.status = 'invalidated';
+        record.invalidationReason = reason;
+        record.updatedAt = Date.now();
+        this.flush();
+        return record;
+    }
+    load() {
+        if (!this.filePath)
+            return;
+        try {
+            const stored = atomicReadJson(this.filePath);
+            if (!stored || stored.version !== STORE_VERSION || stored.channelKey !== this.channelKey)
+                return;
+            for (const record of stored.records ?? []) {
+                if (record?.taskId && record?.interaction?.id)
+                    this.records.set(record.taskId, record);
+            }
+            this.cleanup(true);
+        }
+        catch (error) {
+            logger.warn(`[WeCom] Ignoring unreadable card store for ${this.channelKey}: ${String(error)}`);
+            this.records.clear();
+        }
+    }
+    cleanup(flushWhenChanged = false) {
+        const now = Date.now();
+        let changed = false;
+        for (const [taskId, record] of this.records) {
+            const terminalExpiry = record.updatedAt + DEFAULT_CARD_RETENTION_MS;
+            const pendingExpiry = (record.expiresAt ?? record.createdAt + 7 * DEFAULT_CARD_RETENTION_MS)
+                + DEFAULT_CARD_RETENTION_MS;
+            const expiresAt = record.status === 'pending' ? pendingExpiry : terminalExpiry;
+            if (now > expiresAt) {
+                this.records.delete(taskId);
+                changed = true;
+            }
+        }
+        if (changed && flushWhenChanged)
+            this.flush();
+    }
+    flush() {
+        if (!this.filePath)
+            return;
+        writePrivateJson(this.filePath, {
+            version: STORE_VERSION,
+            channelKey: this.channelKey,
+            records: [...this.records.values()],
+        });
+    }
+}
+export function wecomChannelDataPaths(agentAid, channelKey) {
+    const safeKey = encodeURIComponent(channelKey);
+    const dir = path.join(agentDataDir(agentAid), 'channels', safeKey);
+    return {
+        dedupFile: path.join(dir, 'wecom-message-dedup.json'),
+        cardFile: path.join(dir, 'wecom-cards.json'),
+    };
+}
+export function createWecomCardTaskId(channelKey, interactionId) {
+    const hash = crypto.createHash('sha256').update(`${channelKey}\0${interactionId}`).digest('hex').slice(0, 32);
+    return `ec_${hash}`;
+}