opencode-dingtalk 0.2.0

package/README.md

@@ -0,0 +1,39 @@
+# @ali/opencode-dingtalk
+
+
+
+## Installation
+
+Install my-project with npm
+
+```bash
+  npm install my-project
+  cd my-project
+```
+    
+## Environment Variables
+
+To run this project, you will need to add the following environment variables to your .env file
+
+`API_KEY`
+
+`ANOTHER_API_KEY`
+
+
+## Documentation
+
+[Documentation](https://<your documentation link>)
+
+
+## Authors
+
+- [@<you>](<how ot contact you>)
+
+
+## Contributing
+
+Contributions are always welcome!
+
+See `contributing.md` for ways to get started.
+
+Please adhere to this project's `code of conduct`.

package/dist/__tests__/connection-manager.test.js

@@ -0,0 +1,107 @@
+import { ConnectionManager, ConnectionState } from '../connection-manager.js';
+describe('ConnectionManager', () => {
+    let manager;
+    beforeEach(() => {
+        manager = new ConnectionManager('test-instance', {
+            reconnectTimeoutMs: 200,
+            maxReconnectAttempts: 3,
+            watchdogIntervalMs: 100,
+        });
+    });
+    afterEach(() => {
+        manager.cleanup();
+    });
+    describe('state transitions', () => {
+        it('should start in DISCONNECTED state', () => {
+            expect(manager.getState()).toBe(ConnectionState.DISCONNECTED);
+        });
+        it('should transition to CONNECTED on start', () => {
+            const stateChanges = [];
+            manager.on('stateChange', (_oldState, newState) => {
+                stateChanges.push(newState);
+            });
+            manager.start();
+            expect(stateChanges).toContain(ConnectionState.CONNECTED);
+            expect(manager.getState()).toBe(ConnectionState.CONNECTED);
+        });
+        it('should transition to DISCONNECTED on stop', () => {
+            manager.start();
+            manager.stop();
+            expect(manager.getState()).toBe(ConnectionState.DISCONNECTED);
+        });
+        it('should not duplicate state on repeated start', () => {
+            manager.start();
+            manager.start();
+            expect(manager.getState()).toBe(ConnectionState.CONNECTED);
+        });
+    });
+    describe('metrics', () => {
+        it('should track connectedAt on start', () => {
+            manager.start();
+            const metrics = manager.getMetrics();
+            expect(metrics.connectedAt).not.toBeNull();
+        });
+        it('should clear connectedAt on stop', () => {
+            manager.start();
+            manager.stop();
+            const metrics = manager.getMetrics();
+            expect(metrics.connectedAt).toBeNull();
+        });
+        it('should accumulate totalConnectedMs', () => {
+            manager.start();
+            manager.stop();
+            const metrics = manager.getMetrics();
+            expect(metrics.totalConnectedMs).toBeGreaterThan(0);
+        });
+        it('should return empty metrics initially', () => {
+            const metrics = manager.getMetrics();
+            expect(metrics.connectedAt).toBeNull();
+            expect(metrics.totalConnectedMs).toBe(0);
+            expect(metrics.reconnectAttempts).toBe(0);
+        });
+    });
+    describe('isConnected', () => {
+        it('should return false when disconnected', () => {
+            expect(manager.isConnected).toBe(false);
+        });
+        it('should return true when connected', () => {
+            manager.start();
+            expect(manager.isConnected).toBe(true);
+        });
+    });
+    describe('config', () => {
+        it('should expose config via getter', () => {
+            const config = manager.config;
+            expect(config.reconnectTimeoutMs).toBe(200);
+            expect(config.maxReconnectAttempts).toBe(3);
+        });
+        it('should allow config updates', () => {
+            manager.updateConfig({ reconnectTimeoutMs: 500 });
+            expect(manager.config.reconnectTimeoutMs).toBe(500);
+        });
+    });
+    describe('events', () => {
+        it('should emit connected event on start', () => {
+            const connectedFn = jest.fn();
+            manager.on('connected', connectedFn);
+            manager.start();
+            expect(connectedFn).toHaveBeenCalled();
+        });
+        it('should emit disconnected event on stop', () => {
+            const disconnectedFn = jest.fn();
+            manager.on('disconnected', disconnectedFn);
+            manager.start();
+            manager.stop();
+            expect(disconnectedFn).toHaveBeenCalled();
+        });
+    });
+    describe('cleanup', () => {
+        it('should stop and remove all listeners', () => {
+            const handler = jest.fn();
+            manager.on('stateChange', handler);
+            manager.cleanup();
+            manager.start();
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/__tests__/message-queue.test.js

@@ -0,0 +1,298 @@
+import { MessageQueue, MessageType, MessageStatus } from '../message-queue.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+describe('MessageQueue', () => {
+    let queue;
+    let tempDir;
+    beforeEach(() => {
+        // 创建临时目录
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'queue-test-'));
+        queue = new MessageQueue({
+            instanceId: 'test-instance',
+            storagePath: tempDir,
+            maxSize: 10,
+            inboundTTL: 1000,
+            outboundTTL: 2000,
+            maxRetries: 2,
+            retryDelays: [100, 200],
+            processInterval: 1000,
+            batchSize: 5,
+        });
+    });
+    afterEach(() => {
+        queue.stop();
+        // 清理临时目录
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // 忽略清理错误
+        }
+    });
+    describe('enqueue', () => {
+        it('should add item to queue', () => {
+            const id = queue.enqueue({
+                type: MessageType.INBOUND,
+                content: 'test message',
+                target: 'user123',
+                maxRetries: 3,
+            });
+            expect(id).toBeDefined();
+            expect(typeof id).toBe('string');
+            const stats = queue.getStats();
+            expect(stats.total).toBe(1);
+            expect(stats.pending).toBe(1);
+        });
+        it('should generate unique IDs for each message', () => {
+            const id1 = queue.enqueue({
+                type: MessageType.INBOUND,
+                content: 'message 1',
+                target: 'user123',
+                maxRetries: 3,
+            });
+            const id2 = queue.enqueue({
+                type: MessageType.INBOUND,
+                content: 'message 2',
+                target: 'user123',
+                maxRetries: 3,
+            });
+            expect(id1).not.toBe(id2);
+        });
+        it('should evict oldest item when queue is full', () => {
+            // 添加 10 条消息（达到 maxSize）
+            const ids = [];
+            for (let i = 0; i < 10; i++) {
+                const id = queue.enqueue({
+                    type: MessageType.INBOUND,
+                    content: `message ${i}`,
+                    target: 'user123',
+                    maxRetries: 3,
+                });
+                ids.push(id);
+            }
+            // 添加第 11 条，应该驱逐第 1 条
+            const newId = queue.enqueue({
+                type: MessageType.INBOUND,
+                content: 'message 10',
+                target: 'user123',
+                maxRetries: 3,
+            });
+            const stats = queue.getStats();
+            // 队列应该保持在 maxSize 以内
+            expect(stats.total).toBeLessThanOrEqual(10);
+            // 新消息应该存在
+            const newItem = queue.getItem(newId);
+            expect(newItem).toBeDefined();
+        });
+        it('should set correct TTL based on message type', () => {
+            const inboundId = queue.enqueue({
+                type: MessageType.INBOUND,
+                content: 'inbound',
+                target: 'user123',
+                maxRetries: 3,
+            });
+            const outboundId = queue.enqueue({
+                type: MessageType.OUTBOUND,
+                content: 'outbound',
+                target: 'user123',
+                maxRetries: 3,
+            });
+            const inboundItem = queue.getItem(inboundId);
+            const outboundItem = queue.getItem(outboundId);
+            expect(inboundItem).toBeDefined();
+            expect(outboundItem).toBeDefined();
+            // 入站消息 TTL 应该更短
+            const inboundTtl = inboundItem.expiresAt - inboundItem.createdAt;
+            const outboundTtl = outboundItem.expiresAt - outboundItem.createdAt;
+            expect(inboundTtl).toBeLessThan(outboundTtl);
+        });
+    });
+    describe('dequeue', () => {
+        it('should return items in FIFO order', () => {
+            queue.enqueue({ type: MessageType.INBOUND, content: 'first', target: 'user123', maxRetries: 3 });
+            queue.enqueue({ type: MessageType.INBOUND, content: 'second', target: 'user123', maxRetries: 3 });
+            const first = queue.dequeue(MessageType.INBOUND);
+            const second = queue.dequeue(MessageType.INBOUND);
+            expect(first).toBeDefined();
+            expect(second).toBeDefined();
+            expect(first.content).toBe('first');
+            expect(second.content).toBe('second');
+        });
+        it('should filter by type', () => {
+            queue.enqueue({ type: MessageType.INBOUND, content: 'inbound', target: 'user123', maxRetries: 3 });
+            queue.enqueue({ type: MessageType.OUTBOUND, content: 'outbound', target: 'user123', maxRetries: 3 });
+            const inboundItem = queue.dequeue(MessageType.INBOUND);
+            expect(inboundItem).toBeDefined();
+            expect(inboundItem.type).toBe(MessageType.INBOUND);
+            const outboundItem = queue.dequeue(MessageType.OUTBOUND);
+            expect(outboundItem).toBeDefined();
+            expect(outboundItem.type).toBe(MessageType.OUTBOUND);
+        });
+        it('should return null when queue is empty', () => {
+            const item = queue.dequeue(MessageType.INBOUND);
+            expect(item).toBeNull();
+        });
+        it('should mark item as SENDING after dequeue', () => {
+            const id = queue.enqueue({ type: MessageType.INBOUND, content: 'test', target: 'user123', maxRetries: 3 });
+            queue.dequeue(MessageType.INBOUND);
+            const item = queue.getItem(id);
+            expect(item).toBeDefined();
+            expect(item.status).toBe(MessageStatus.SENDING);
+        });
+    });
+    describe('ack', () => {
+        it('should mark item as acked and remove from queue', () => {
+            const id = queue.enqueue({ type: MessageType.INBOUND, content: 'test', target: 'user123', maxRetries: 3 });
+            queue.ack(id);
+            const stats = queue.getStats();
+            expect(stats.total).toBe(0);
+            const item = queue.getItem(id);
+            expect(item).toBeUndefined();
+        });
+        it('should do nothing for non-existent ID', () => {
+            queue.ack('non-existent-id');
+            const stats = queue.getStats();
+            expect(stats.total).toBe(0);
+        });
+    });
+    describe('nack', () => {
+        it('should retry item if retries remaining', () => {
+            const id = queue.enqueue({ type: MessageType.OUTBOUND, content: 'test', target: 'user123', maxRetries: 3 });
+            queue.nack(id, 'network error');
+            const item = queue.getItem(id);
+            expect(item).toBeDefined();
+            expect(item.retryCount).toBe(1);
+            expect(item.status).toBe(MessageStatus.PENDING);
+            expect(item.lastError).toBe('network error');
+        });
+        it('should mark as failed if max retries exceeded', () => {
+            const id = queue.enqueue({ type: MessageType.OUTBOUND, content: 'test', target: 'user123', maxRetries: 1 });
+            queue.nack(id, 'error 1');
+            queue.nack(id, 'error 2');
+            const item = queue.getItem(id);
+            expect(item).toBeDefined();
+            expect(item.status).toBe(MessageStatus.FAILED);
+            expect(item.retryCount).toBe(2);
+        });
+        it('should record error history', () => {
+            const id = queue.enqueue({ type: MessageType.OUTBOUND, content: 'test', target: 'user123', maxRetries: 3 });
+            queue.nack(id, 'error 1');
+            queue.nack(id, 'error 2');
+            const item = queue.getItem(id);
+            expect(item).toBeDefined();
+            expect(item.errorHistory).toBeDefined();
+            expect(item.errorHistory.length).toBe(2);
+        });
+    });
+    describe('drain', () => {
+        it('should return multiple items of specified type', () => {
+            for (let i = 0; i < 5; i++) {
+                queue.enqueue({ type: MessageType.INBOUND, content: `msg ${i}`, target: 'user123', maxRetries: 3 });
+            }
+            const items = queue.drain(MessageType.INBOUND, 3);
+            expect(items.length).toBe(3);
+            expect(items[0].content).toBe('msg 0');
+            expect(items[1].content).toBe('msg 1');
+            expect(items[2].content).toBe('msg 2');
+        });
+        it('should mark items as SENDING', () => {
+            queue.enqueue({ type: MessageType.INBOUND, content: 'test', target: 'user123', maxRetries: 3 });
+            const items = queue.drain(MessageType.INBOUND, 10);
+            expect(items.length).toBe(1);
+            expect(items[0].status).toBe(MessageStatus.SENDING);
+        });
+        it('should return empty array when no items match', () => {
+            queue.enqueue({ type: MessageType.OUTBOUND, content: 'outbound', target: 'user123', maxRetries: 3 });
+            const items = queue.drain(MessageType.INBOUND, 10);
+            expect(items.length).toBe(0);
+        });
+    });
+    describe('cleanup', () => {
+        it('should remove expired items', async () => {
+            queue.enqueue({ type: MessageType.INBOUND, content: 'test', target: 'user123', maxRetries: 3 });
+            // 等待 TTL 过期
+            await new Promise(resolve => setTimeout(resolve, 1500));
+            const result = queue.cleanup();
+            expect(result.expired).toBe(1);
+            const stats = queue.getStats();
+            expect(stats.total).toBe(0);
+        });
+        it('should not remove non-expired items', () => {
+            queue.enqueue({ type: MessageType.OUTBOUND, content: 'test', target: 'user123', maxRetries: 3 });
+            const result = queue.cleanup();
+            expect(result.expired).toBe(0);
+            const stats = queue.getStats();
+            expect(stats.total).toBe(1);
+        });
+    });
+    describe('persistence', () => {
+        it('should save and load queue', async () => {
+            queue.enqueue({ type: MessageType.INBOUND, content: 'test', target: 'user123', maxRetries: 3 });
+            await queue.save();
+            // 创建新队列实例
+            const queue2 = new MessageQueue({
+                instanceId: 'test-instance',
+                storagePath: tempDir,
+            });
+            await queue2.load();
+            const stats = queue2.getStats();
+            expect(stats.total).toBe(1);
+            queue2.stop();
+        });
+        it('should handle missing file gracefully', async () => {
+            const queue2 = new MessageQueue({
+                instanceId: 'non-existent',
+                storagePath: tempDir,
+            });
+            await queue2.load();
+            const stats = queue2.getStats();
+            expect(stats.total).toBe(0);
+            queue2.stop();
+        });
+    });
+    describe('getStats', () => {
+        it('should return correct statistics', () => {
+            queue.enqueue({ type: MessageType.INBOUND, content: 'pending', target: 'user123', maxRetries: 3 });
+            queue.enqueue({ type: MessageType.INBOUND, content: 'sending', target: 'user123', maxRetries: 3 });
+            queue.enqueue({ type: MessageType.OUTBOUND, content: 'failed', target: 'user123', maxRetries: 1 });
+            // 标记一个为 SENDING
+            queue.dequeue(MessageType.INBOUND);
+            // 标记一个为 FAILED
+            const failedId = queue.dequeue(MessageType.OUTBOUND).id;
+            queue.nack(failedId, 'error');
+            queue.nack(failedId, 'error');
+            const stats = queue.getStats();
+            expect(stats.total).toBe(3);
+            expect(stats.pending).toBe(1);
+            expect(stats.sending).toBe(1);
+            expect(stats.failed).toBe(1);
+        });
+    });
+    describe('peek', () => {
+        it('should return next item without removing it', () => {
+            queue.enqueue({ type: MessageType.INBOUND, content: 'first', target: 'user123', maxRetries: 3 });
+            queue.enqueue({ type: MessageType.INBOUND, content: 'second', target: 'user123', maxRetries: 3 });
+            const peeked = queue.peek(MessageType.INBOUND);
+            expect(peeked).toBeDefined();
+            expect(peeked.content).toBe('first');
+            const stats = queue.getStats();
+            expect(stats.total).toBe(2);
+        });
+        it('should return null when queue is empty', () => {
+            const peeked = queue.peek(MessageType.INBOUND);
+            expect(peeked).toBeNull();
+        });
+    });
+    describe('lifecycle', () => {
+        it('should start and stop without errors', () => {
+            expect(() => queue.start()).not.toThrow();
+            expect(() => queue.stop()).not.toThrow();
+        });
+        it('should not start twice', () => {
+            queue.start();
+            queue.start(); // 应该不会抛出错误
+            queue.stop();
+        });
+    });
+});

package/dist/config.js

@@ -0,0 +1,181 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { logger } from "./logger.js";
+// ============ Config File Paths ============
+const CONFIG_FILENAME = "opencode-dingtalk.json";
+const LEGACY_CONFIG_FILENAME = "lingji-bot-core.json";
+function getConfigPaths() {
+    const paths = [];
+    const opencodeHome = process.env.OPENCODE_HOME;
+    if (opencodeHome && opencodeHome.length > 0) {
+        paths.push(path.join(opencodeHome, CONFIG_FILENAME));
+        paths.push(path.join(opencodeHome, LEGACY_CONFIG_FILENAME));
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    paths.push(path.join(xdgConfig, "opencode", CONFIG_FILENAME));
+    paths.push(path.join(xdgConfig, "opencode", LEGACY_CONFIG_FILENAME));
+    return paths;
+}
+// ============ Config File Loading ============
+let cachedFileConfig = null;
+let configFilePath = null;
+export function loadFileConfig(forceReload = false) {
+    if (cachedFileConfig && !forceReload) {
+        return cachedFileConfig;
+    }
+    const paths = getConfigPaths();
+    for (const cp of paths) {
+        try {
+            const raw = fs.readFileSync(cp, "utf8");
+            const parsed = JSON.parse(raw);
+            // For single-instance callers, return the first object or first array element
+            if (Array.isArray(parsed)) {
+                cachedFileConfig = parsed[0] ?? {};
+            }
+            else {
+                cachedFileConfig = parsed;
+            }
+            configFilePath = cp;
+            logger.log(`[opencode-dingtalk] Config loaded from ${cp}`);
+            return cachedFileConfig;
+        }
+        catch {
+            continue;
+        }
+    }
+    cachedFileConfig = {};
+    configFilePath = null;
+    return {};
+}
+export function getConfigFilePath() {
+    return configFilePath;
+}
+export function getDefaultConfigPath() {
+    const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    return path.join(xdgConfig, "opencode", CONFIG_FILENAME);
+}
+// ============ Config Resolution (single instance) ============
+export function resolveConfig(params = {}) {
+    const file = loadFileConfig();
+    const messageTypeRaw = params.messageType ||
+        process.env.DINGTALK_MESSAGE_TYPE ||
+        file.messageType ||
+        "markdown";
+    const messageType = messageTypeRaw === "text" ||
+        messageTypeRaw === "markdown" ||
+        messageTypeRaw === "card"
+        ? messageTypeRaw
+        : "markdown";
+    const clientId = params.clientId || process.env.DINGTALK_CLIENT_ID || file.clientId;
+    return {
+        name: file.name || clientId,
+        clientId,
+        clientSecret: params.clientSecret ||
+            process.env.DINGTALK_CLIENT_SECRET ||
+            file.clientSecret,
+        robotCode: params.robotCode || process.env.DINGTALK_ROBOT_CODE || file.robotCode,
+        messageType,
+        cardTemplateId: params.cardTemplateId ||
+            process.env.DINGTALK_CARD_TEMPLATE_ID ||
+            file.cardTemplateId,
+        opencodeUrl: params.opencodeUrl ||
+            process.env.OPENCODE_URL ||
+            file.opencodeUrl ||
+            "http://127.0.0.1:4096",
+        autoStart: file.autoStart ?? false,
+        notifyLevel: (() => {
+            const raw = process.env.DINGTALK_NOTIFY_LEVEL || file.notifyLevel || "normal";
+            return raw === "minimal" || raw === "normal" || raw === "verbose"
+                ? raw
+                : "normal";
+        })(),
+        atAllKeywords: file.atAllKeywords || [],
+    };
+}
+// ============ Multi-Instance Config Resolution ============
+/**
+ * Resolve all instance configs from the config file.
+ *
+ * Config file root type determines the mode:
+ *   - Object → single instance (wrapped in array)
+ *   - Array  → multiple instances
+ *
+ * Each element is resolved independently with env-var fallbacks.
+ */
+export function resolveInstances() {
+    const paths = getConfigPaths();
+    for (const cp of paths) {
+        try {
+            const raw = fs.readFileSync(cp, "utf8");
+            const parsed = JSON.parse(raw);
+            configFilePath = cp;
+            const items = Array.isArray(parsed)
+                ? parsed
+                : [parsed];
+            return items.map((item) => resolveInstanceConfig(item));
+        }
+        catch {
+            continue;
+        }
+    }
+    // No config file found — try env vars as a single instance
+    return [resolveConfig()];
+}
+function resolveInstanceConfig(item) {
+    const messageTypeRaw = item.messageType || "markdown";
+    const messageType = messageTypeRaw === "text" ||
+        messageTypeRaw === "markdown" ||
+        messageTypeRaw === "card"
+        ? messageTypeRaw
+        : "markdown";
+    const clientId = item.clientId || process.env.DINGTALK_CLIENT_ID;
+    return {
+        name: item.name || clientId,
+        clientId,
+        clientSecret: item.clientSecret || process.env.DINGTALK_CLIENT_SECRET,
+        robotCode: item.robotCode,
+        messageType,
+        cardTemplateId: item.cardTemplateId,
+        opencodeUrl: item.opencodeUrl || "http://127.0.0.1:4096",
+        autoStart: item.autoStart ?? false,
+        notifyLevel: (() => {
+            const raw = item.notifyLevel || "normal";
+            return raw === "minimal" || raw === "normal" || raw === "verbose"
+                ? raw
+                : "normal";
+        })(),
+        atAllKeywords: item.atAllKeywords || [],
+    };
+}
+// ============ Config Template ============
+export function generateConfigTemplate() {
+    const template = {
+        clientId: "your-dingtalk-app-key",
+        clientSecret: "your-dingtalk-app-secret",
+        robotCode: "your-robot-code",
+        messageType: "markdown",
+        cardTemplateId: "",
+        opencodeUrl: "http://127.0.0.1:4096",
+        autoStart: false,
+        notifyLevel: "normal",
+        atAllKeywords: [
+            "代码",
+            "程序",
+            "bug",
+            "错误",
+            "修复",
+            "开发",
+            "代码",
+            "program",
+            "error",
+            "fix",
+            "dev",
+            "帮助",
+            "怎么",
+            "如何",
+            "为什么",
+        ],
+    };
+    return JSON.stringify(template, null, 2) + "\n";
+}