opencode-dingtalk 0.2.0

package/dist/lock.js

@@ -0,0 +1,57 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getDataDir } from "./utils.js";
+function getLockFilePath(clientId) {
+    return path.join(getDataDir(), "bot-" + clientId + ".lock");
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Acquire a file-based lock so only one process can run the bot per clientId.
+ * Returns true if lock acquired, false if another live process holds the lock.
+ */
+export function acquireBotLock(clientId) {
+    const lockPath = getLockFilePath(clientId);
+    try {
+        const raw = fs.readFileSync(lockPath, "utf8");
+        const lock = JSON.parse(raw);
+        if (lock.pid !== process.pid && isProcessAlive(lock.pid)) {
+            return false;
+        }
+    }
+    catch {
+        // no lock file or unreadable, safe to acquire
+    }
+    try {
+        fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+        const info = { pid: process.pid, startedAt: Date.now() };
+        fs.writeFileSync(lockPath, JSON.stringify(info) + "\n");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Release the file lock, but only if current process owns it (PID matches).
+ */
+export function releaseBotLock(clientId) {
+    const lockPath = getLockFilePath(clientId);
+    try {
+        const raw = fs.readFileSync(lockPath, "utf8");
+        const lock = JSON.parse(raw);
+        if (lock.pid === process.pid) {
+            fs.unlinkSync(lockPath);
+        }
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/logger.js

@@ -0,0 +1,43 @@
+import { appendFileSync } from "fs";
+import { format } from "util";
+/**
+ * 获取当前小时的日志文件名
+ * 格式: opencode-dingtalk.2026-04-03_01.log
+ */
+function getLogFileName() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hour = String(now.getHours()).padStart(2, "0");
+    return `opencode-dingtalk.${year}-${month}-${day}_${hour}.log`;
+}
+/**
+ * 获取日志文件完整路径
+ */
+function getLogFilePath() {
+    const fileName = getLogFileName();
+    return `/tmp/${fileName}`;
+}
+/**
+ * 将日志写入文件
+ */
+function writeToFile(level, ...args) {
+    try {
+        const logFilePath = getLogFilePath();
+        const timestamp = new Date().toISOString();
+        const message = format(...args);
+        const logLine = `[${timestamp}] [${level}] ${message}\n`;
+        appendFileSync(logFilePath, logLine, { encoding: "utf-8" });
+    }
+    catch (error) {
+        // 如果写入失败，静默处理，避免影响主程序
+    }
+}
+export const logger = {
+    log: (...args) => writeToFile("LOG", ...args),
+    info: (...args) => writeToFile("INFO", ...args),
+    warn: (...args) => writeToFile("WARN", ...args),
+    error: (...args) => writeToFile("ERROR", ...args),
+    debug: (...args) => writeToFile("DEBUG", ...args),
+};

package/dist/message-queue.js

@@ -0,0 +1,604 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { getDataDir } from "./utils.js";
+import { logger } from "./logger.js";
+// ============ Type Definitions ============
+export var MessageStatus;
+(function (MessageStatus) {
+    MessageStatus["PENDING"] = "pending";
+    MessageStatus["SENDING"] = "sending";
+    MessageStatus["FAILED"] = "failed";
+    MessageStatus["EXPIRED"] = "expired";
+    MessageStatus["ACKED"] = "acked"; // 已确认成功
+})(MessageStatus || (MessageStatus = {}));
+export var MessageType;
+(function (MessageType) {
+    MessageType["INBOUND"] = "inbound";
+    MessageType["OUTBOUND"] = "outbound"; // 出站消息（机器人发送给用户）
+})(MessageType || (MessageType = {}));
+// 兼容性别名
+export const QueueType = MessageType;
+// ============ Default Configuration ============
+const DEFAULT_CONFIG = {
+    storagePath: getDataDir(),
+    instanceId: 'default',
+    inboundTTL: 5 * 60 * 1000, // 5 分钟
+    outboundTTL: 60 * 60 * 1000, // 1 小时
+    maxSize: 1000,
+    maxRetries: 3,
+    retryDelays: [2000, 5000, 10000], // 2s, 5s, 10s
+    processInterval: 30000, // 30 秒
+    batchSize: 10
+};
+// ============ MessageQueue Class ============
+export class MessageQueue {
+    config;
+    items;
+    processTimer;
+    saveTimer;
+    lockPath;
+    filePath;
+    constructor(configOrInstanceId) {
+        // 支持两种调用方式：
+        // 1. new MessageQueue(instanceId: string)
+        // 2. new MessageQueue(config: Partial<QueueConfig> & { instanceId: string })
+        if (typeof configOrInstanceId === 'string') {
+            this.config = { ...DEFAULT_CONFIG, instanceId: configOrInstanceId };
+        }
+        else {
+            this.config = { ...DEFAULT_CONFIG, ...configOrInstanceId };
+        }
+        this.items = new Map();
+        // 确保存储目录存在
+        this.ensureStorageDir();
+        // 设置文件路径
+        this.lockPath = path.join(this.config.storagePath, `message-queue-${this.config.instanceId}.lock`);
+        this.filePath = path.join(this.config.storagePath, `message-queue-${this.config.instanceId}.json`);
+    }
+    // ============ Storage Helpers ============
+    ensureStorageDir() {
+        try {
+            fs.mkdirSync(this.config.storagePath, { recursive: true });
+        }
+        catch {
+            // 忽略目录创建错误
+        }
+    }
+    getQueueFilePath() {
+        return this.filePath;
+    }
+    getLockFilePath() {
+        return this.lockPath;
+    }
+    // ============ File Lock ============
+    async acquireLock(timeoutMs = 5000) {
+        const lockPath = this.getLockFilePath();
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeoutMs) {
+            try {
+                // 尝试创建锁文件（独占模式）
+                const fd = fs.openSync(lockPath, 'wx');
+                // 写入进程ID和时间戳
+                fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+                return fd;
+            }
+            catch (err) {
+                if (err.code === 'EEXIST') {
+                    // 锁文件已存在，检查是否过期（超过30秒视为过期）
+                    try {
+                        const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+                        if (Date.now() - lockData.timestamp > 30000) {
+                            // 锁已过期，删除并重试
+                            fs.unlinkSync(lockPath);
+                            continue;
+                        }
+                    }
+                    catch {
+                        // 锁文件损坏，删除并重试
+                        try {
+                            fs.unlinkSync(lockPath);
+                        }
+                        catch { }
+                        continue;
+                    }
+                    // 等待100ms后重试
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+                else {
+                    // 其他错误，返回 null
+                    return null;
+                }
+            }
+        }
+        return null; // 超时
+    }
+    releaseLock(fd) {
+        if (fd === null)
+            return;
+        try {
+            fs.closeSync(fd);
+            fs.unlinkSync(this.getLockFilePath());
+        }
+        catch {
+            // 忽略释放锁时的错误
+        }
+    }
+    // ============ Core Operations ============
+    /**
+     * 添加消息到队列
+     * 支持两种调用方式：
+     * 1. enqueue(item: Omit<QueueItem, ...>): string
+     * 2. enqueue(type: MessageType, payload: unknown, options?: {...}): string
+     *
+     * @returns 生成的消息 ID
+     */
+    enqueue(itemOrType, payload, options = {}) {
+        const now = Date.now();
+        const id = randomUUID();
+        let item;
+        // 判断调用方式
+        if (typeof itemOrType === 'string') {
+            // 方式2: enqueue(type, payload, options)
+            item = {
+                type: itemOrType,
+                content: typeof payload === 'string' ? payload : JSON.stringify(payload),
+                target: options.userId || 'unknown',
+                topic: options.topic,
+                maxRetries: options.maxRetries ?? this.config.maxRetries,
+                metadata: {
+                    messageId: options.messageId,
+                    originalPayload: payload,
+                },
+            };
+        }
+        else {
+            // 方式1: enqueue(item)
+            item = itemOrType;
+        }
+        // 根据消息类型计算过期时间
+        const ttl = item.type === MessageType.INBOUND
+            ? this.config.inboundTTL
+            : this.config.outboundTTL;
+        const queueItem = {
+            ...item,
+            id,
+            status: MessageStatus.PENDING,
+            createdAt: now,
+            updatedAt: now,
+            expiresAt: now + ttl,
+            retryCount: 0,
+            maxRetries: item.maxRetries ?? this.config.maxRetries,
+        };
+        // 检查队列容量
+        if (this.items.size >= this.config.maxSize) {
+            this.evictOldest();
+        }
+        this.items.set(id, queueItem);
+        logger.info(`[MessageQueue] Message enqueued: ${id}, type=${item.type}, target=${item.target}`);
+        // 异步保存
+        this.save().catch(err => {
+            logger.error(`[MessageQueue] Failed to save after enqueue: ${err}`);
+        });
+        return id;
+    }
+    /**
+     * 获取下一个待处理消息
+     * @param type 可选，指定消息类型
+     * @returns 队列项或 null
+     */
+    dequeue(type) {
+        const now = Date.now();
+        for (const [id, item] of this.items) {
+            // 过滤条件：状态为 PENDING，未过期，类型匹配
+            if (item.status !== MessageStatus.PENDING)
+                continue;
+            if (item.expiresAt < now) {
+                // 标记为过期
+                item.status = MessageStatus.EXPIRED;
+                item.updatedAt = now;
+                continue;
+            }
+            if (type && item.type !== type)
+                continue;
+            // 检查重试延迟
+            if (item.nextRetryAt && item.nextRetryAt > now)
+                continue;
+            // 更新状态为 SENDING
+            item.status = MessageStatus.SENDING;
+            item.updatedAt = now;
+            return item;
+        }
+        return null;
+    }
+    /**
+     * 确认消息处理成功
+     * @param id 消息 ID
+     */
+    ack(id) {
+        const item = this.items.get(id);
+        if (!item)
+            return;
+        item.status = MessageStatus.ACKED;
+        item.updatedAt = Date.now();
+        logger.info(`[MessageQueue] Message acked: ${id}`);
+        // 从队列中移除
+        this.items.delete(id);
+        // 异步保存
+        this.save().catch(err => {
+            logger.error(`[MessageQueue] Failed to save after ack: ${err}`);
+        });
+    }
+    /**
+     * 消息处理失败，重新入队
+     * @param id 消息 ID
+     * @param error 错误信息
+     */
+    nack(id, error) {
+        const item = this.items.get(id);
+        if (!item)
+            return;
+        const now = Date.now();
+        item.retryCount++;
+        item.lastError = error;
+        item.updatedAt = now;
+        // 记录错误历史
+        if (!item.errorHistory) {
+            item.errorHistory = [];
+        }
+        item.errorHistory.push(`[${new Date(now).toISOString()}] ${error || 'Unknown error'}`);
+        // 检查是否超过最大重试次数
+        if (item.retryCount >= item.maxRetries) {
+            item.status = MessageStatus.FAILED;
+            logger.warn(`[MessageQueue] Message failed after ${item.retryCount} retries: ${id}`);
+        }
+        else {
+            // 计算下次重试时间
+            const delayIndex = Math.min(item.retryCount - 1, this.config.retryDelays.length - 1);
+            const delay = this.config.retryDelays[delayIndex];
+            item.nextRetryAt = now + delay;
+            item.lastRetryAt = now;
+            item.status = MessageStatus.PENDING;
+            logger.info(`[MessageQueue] Message nacked, will retry in ${delay}ms: ${id}`);
+        }
+        // 异步保存
+        this.save().catch(err => {
+            logger.error(`[MessageQueue] Failed to save after nack: ${err}`);
+        });
+    }
+    /**
+     * 查看队列头部消息（不移除）
+     * @param type 可选，指定消息类型
+     * @returns 队列项或 null
+     */
+    peek(type) {
+        const now = Date.now();
+        for (const [id, item] of this.items) {
+            if (item.status !== MessageStatus.PENDING)
+                continue;
+            if (item.expiresAt < now)
+                continue;
+            if (type && item.type !== type)
+                continue;
+            if (item.nextRetryAt && item.nextRetryAt > now)
+                continue;
+            return item;
+        }
+        return null;
+    }
+    /**
+     * 批量获取消息
+     * @param type 消息类型
+     * @param count 获取数量
+     * @returns 队列项数组
+     */
+    drain(type, count) {
+        const result = [];
+        const now = Date.now();
+        for (const [id, item] of this.items) {
+            if (result.length >= count)
+                break;
+            if (item.status !== MessageStatus.PENDING)
+                continue;
+            if (item.expiresAt < now) {
+                item.status = MessageStatus.EXPIRED;
+                item.updatedAt = now;
+                continue;
+            }
+            if (item.type !== type)
+                continue;
+            if (item.nextRetryAt && item.nextRetryAt > now)
+                continue;
+            item.status = MessageStatus.SENDING;
+            item.updatedAt = now;
+            result.push(item);
+        }
+        return result;
+    }
+    /**
+     * 清理过期消息
+     * @returns 清理的数量
+     */
+    cleanup() {
+        const now = Date.now();
+        let expired = 0;
+        let evicted = 0;
+        for (const [id, item] of this.items) {
+            // 检查过期
+            if (item.expiresAt < now && item.status !== MessageStatus.EXPIRED) {
+                item.status = MessageStatus.EXPIRED;
+                item.updatedAt = now;
+                expired++;
+            }
+            // 移除已过期或已确认的消息
+            if (item.status === MessageStatus.EXPIRED || item.status === MessageStatus.ACKED) {
+                this.items.delete(id);
+                evicted++;
+            }
+        }
+        if (expired > 0 || evicted > 0) {
+            logger.info(`[MessageQueue] Cleanup: expired=${expired}, evicted=${evicted}`);
+            // 异步保存
+            this.save().catch(err => {
+                logger.error(`[MessageQueue] Failed to save after cleanup: ${err}`);
+            });
+        }
+        return { expired, evicted };
+    }
+    /**
+     * 获取队列统计信息
+     */
+    getStats() {
+        const now = Date.now();
+        let pending = 0;
+        let sending = 0;
+        let failed = 0;
+        let expired = 0;
+        let totalRetryCount = 0;
+        let oldestTimestamp = now;
+        let oldestPendingTimestamp = now;
+        for (const item of this.items.values()) {
+            switch (item.status) {
+                case MessageStatus.PENDING:
+                    pending++;
+                    if (item.createdAt < oldestPendingTimestamp) {
+                        oldestPendingTimestamp = item.createdAt;
+                    }
+                    break;
+                case MessageStatus.SENDING:
+                    sending++;
+                    break;
+                case MessageStatus.FAILED:
+                    failed++;
+                    break;
+                case MessageStatus.EXPIRED:
+                    expired++;
+                    break;
+            }
+            totalRetryCount += item.retryCount;
+            if (item.createdAt < oldestTimestamp) {
+                oldestTimestamp = item.createdAt;
+            }
+        }
+        const total = this.items.size;
+        const oldestAge = total > 0 ? now - oldestTimestamp : 0;
+        const oldestPendingAge = pending > 0 ? now - oldestPendingTimestamp : 0;
+        const avgRetryCount = total > 0 ? totalRetryCount / total : 0;
+        return {
+            total,
+            pending,
+            sending,
+            processing: sending, // 别名
+            failed,
+            expired,
+            oldestAge,
+            oldestPendingAge,
+            avgRetryCount
+        };
+    }
+    /**
+     * 获取入站队列统计
+     */
+    getInboundStats() {
+        return this.getStatsByType(MessageType.INBOUND);
+    }
+    /**
+     * 获取出站队列统计
+     */
+    getOutboundStats() {
+        return this.getStatsByType(MessageType.OUTBOUND);
+    }
+    /**
+     * 按类型获取队列统计信息
+     */
+    getStatsByType(type) {
+        const now = Date.now();
+        let pending = 0;
+        let sending = 0;
+        let failed = 0;
+        let expired = 0;
+        let totalRetryCount = 0;
+        let oldestTimestamp = now;
+        let oldestPendingTimestamp = now;
+        for (const item of this.items.values()) {
+            if (item.type !== type)
+                continue;
+            switch (item.status) {
+                case MessageStatus.PENDING:
+                    pending++;
+                    if (item.createdAt < oldestPendingTimestamp) {
+                        oldestPendingTimestamp = item.createdAt;
+                    }
+                    break;
+                case MessageStatus.SENDING:
+                    sending++;
+                    break;
+                case MessageStatus.FAILED:
+                    failed++;
+                    break;
+                case MessageStatus.EXPIRED:
+                    expired++;
+                    break;
+            }
+            totalRetryCount += item.retryCount;
+            if (item.createdAt < oldestTimestamp) {
+                oldestTimestamp = item.createdAt;
+            }
+        }
+        const total = pending + sending + failed + expired;
+        const oldestAge = total > 0 ? now - oldestTimestamp : 0;
+        const oldestPendingAge = pending > 0 ? now - oldestPendingTimestamp : 0;
+        const avgRetryCount = total > 0 ? totalRetryCount / total : 0;
+        return {
+            total,
+            pending,
+            sending,
+            processing: sending, // 别名
+            failed,
+            expired,
+            oldestAge,
+            oldestPendingAge,
+            avgRetryCount
+        };
+    }
+    /**
+     * 获取指定消息
+     */
+    getItem(id) {
+        return this.items.get(id);
+    }
+    /**
+     * 获取所有消息（用于诊断）
+     */
+    getAllItems() {
+        return Array.from(this.items.values());
+    }
+    // ============ Persistence ============
+    /**
+     * 从磁盘加载队列
+     */
+    async load() {
+        const filePath = this.getQueueFilePath();
+        const fd = await this.acquireLock();
+        if (fd === null) {
+            logger.warn('[MessageQueue] Failed to acquire lock for load');
+            return;
+        }
+        try {
+            if (!fs.existsSync(filePath)) {
+                return;
+            }
+            const raw = fs.readFileSync(filePath, 'utf8');
+            const data = JSON.parse(raw);
+            // 验证数据格式
+            if (data.version !== 1) {
+                logger.warn(`[MessageQueue] Unknown version: ${data.version}, skipping load`);
+                return;
+            }
+            if (data.instanceId !== this.config.instanceId) {
+                logger.warn(`[MessageQueue] Instance ID mismatch: ${data.instanceId} vs ${this.config.instanceId}`);
+                return;
+            }
+            // 加载消息
+            this.items.clear();
+            for (const item of data.items) {
+                // 验证必要字段
+                if (!item.id || !item.type || !item.status) {
+                    logger.warn(`[MessageQueue] Invalid item, skipping: ${JSON.stringify(item)}`);
+                    continue;
+                }
+                this.items.set(item.id, item);
+            }
+            logger.info(`[MessageQueue] Loaded ${this.items.size} items from disk`);
+        }
+        catch (err) {
+            logger.error(`[MessageQueue] Failed to load: ${err}`);
+        }
+        finally {
+            this.releaseLock(fd);
+        }
+    }
+    /**
+     * 保存队列到磁盘
+     */
+    async save() {
+        const filePath = this.getQueueFilePath();
+        const fd = await this.acquireLock();
+        if (fd === null) {
+            logger.warn('[MessageQueue] Failed to acquire lock for save');
+            return;
+        }
+        try {
+            this.ensureStorageDir();
+            const data = {
+                version: 1,
+                instanceId: this.config.instanceId,
+                updatedAt: Date.now(),
+                items: Array.from(this.items.values())
+            };
+            fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+        }
+        catch (err) {
+            logger.error(`[MessageQueue] Failed to save: ${err}`);
+        }
+        finally {
+            this.releaseLock(fd);
+        }
+    }
+    // ============ Lifecycle ============
+    /**
+     * 启动队列处理定时器
+     */
+    start() {
+        if (this.processTimer) {
+            return;
+        }
+        // 启动处理定时器
+        this.processTimer = setInterval(() => {
+            this.cleanup();
+        }, this.config.processInterval);
+        // 启动保存定时器（每5秒保存一次）
+        this.saveTimer = setInterval(() => {
+            this.save().catch(err => {
+                logger.error(`[MessageQueue] Periodic save failed: ${err}`);
+            });
+        }, 5000);
+        logger.info(`[MessageQueue] Started with instanceId=${this.config.instanceId}`);
+    }
+    /**
+     * 停止队列处理定时器
+     */
+    stop() {
+        if (this.processTimer) {
+            clearInterval(this.processTimer);
+            this.processTimer = undefined;
+        }
+        if (this.saveTimer) {
+            clearInterval(this.saveTimer);
+            this.saveTimer = undefined;
+        }
+        // 最后保存一次
+        this.save().catch(err => {
+            logger.error(`[MessageQueue] Final save failed: ${err}`);
+        });
+        logger.info(`[MessageQueue] Stopped`);
+    }
+    // ============ Private Helpers ============
+    /**
+     * 驱逐最旧的消息
+     */
+    evictOldest() {
+        let oldestId = null;
+        let oldestTimestamp = Date.now();
+        for (const [id, item] of this.items) {
+            if (item.createdAt < oldestTimestamp) {
+                oldestTimestamp = item.createdAt;
+                oldestId = id;
+            }
+        }
+        if (oldestId) {
+            this.items.delete(oldestId);
+            logger.warn(`[MessageQueue] Evicted oldest message: ${oldestId}`);
+        }
+    }
+}