evolcore 0.0.2 → 0.0.3

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}`;
+}