opencode-dingtalk 0.2.0

package/dist/utils.js

@@ -0,0 +1,171 @@
+import os from "node:os";
+import path from "node:path";
+import { getAccessToken as dingtalkGetAccessToken } from "./dingtalk/dingtalk-api.js";
+// ============ Global Data Paths ============
+/**
+ * Global data directory for opencode-dingtalk runtime files (lock, active-users, etc.).
+ * Ensures all bot instances share a single directory regardless of cwd.
+ *
+ * Priority:
+ *   1. $OPENCODE_HOME/opencode-dingtalk
+ *   2. ~/.config/opencode/opencode-dingtalk  (XDG fallback)
+ */
+export function getDataDir() {
+    const home = process.env.OPENCODE_HOME;
+    if (home && home.length > 0)
+        return path.join(home, "opencode-dingtalk");
+    const xdg = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+    return path.join(xdg, "opencode", "opencode-dingtalk");
+}
+/**
+ * @deprecated Use `state.getUsersPersistPath()` instead for per-instance paths.
+ * Kept for backward compat (aem.ts reads the latest user from disk).
+ */
+export function getUsersPersistPath() {
+    return path.join(getDataDir(), "active-users-default.json");
+}
+export async function retryWithBackoff(fn, options = {}) {
+    const { maxRetries = 3, baseDelayMs = 100, log } = options;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            const isRetryable = error.message.includes("401") ||
+                error.message.includes("429") ||
+                error.message.includes("500") ||
+                error.message.includes("fetch");
+            if (!isRetryable || attempt === maxRetries) {
+                throw error;
+            }
+            const delayMs = baseDelayMs * Math.pow(2, attempt - 1);
+            log?.debug?.(`[DingTalk] Retry attempt ${attempt}/${maxRetries} after ${delayMs}ms`);
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    throw new Error("Retry exhausted without returning");
+}
+/**
+ * Get DingTalk access token with caching and retry.
+ * Token is cached on the InstanceState and refreshed 60s before expiry.
+ */
+export async function getAccessToken(state, config, log) {
+    const now = Date.now();
+    if (state.accessToken && state.accessTokenExpiry > now + 60000) {
+        return state.accessToken;
+    }
+    const token = await retryWithBackoff(async () => {
+        const accessToken = await dingtalkGetAccessToken(config.clientId, config.clientSecret);
+        state.accessToken = accessToken;
+        state.accessTokenExpiry = now + 7200 * 1000; // 默认2小时有效期
+        return accessToken;
+    }, { maxRetries: 3, log });
+    return token;
+}
+// ============ Message Helpers ============
+export function splitMessage(text, maxLength = 6000) {
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+        if (remaining.length <= maxLength) {
+            chunks.push(remaining);
+            break;
+        }
+        let splitAt = remaining.lastIndexOf("\n", maxLength);
+        if (splitAt === -1 || splitAt < maxLength / 2) {
+            splitAt = maxLength;
+        }
+        chunks.push(remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).trimStart();
+    }
+    return chunks;
+}
+export function detectMarkdownAndExtractTitle(text, defaultTitle = "OpenCode 消息") {
+    const hasMarkdown = /^[#*>-]|[*_`#[\]]/.test(text) || text.includes("\n");
+    const title = hasMarkdown
+        ? text
+            .split("\n")[0]
+            .replace(/^[#*\s\->]+/, "")
+            .slice(0, 20) || defaultTitle
+        : defaultTitle;
+    return { useMarkdown: hasMarkdown, title };
+}
+/**
+ * Ensure line breaks are rendered correctly in DingTalk markdown.
+ */
+export function ensureMarkdownLineBreaks(text) {
+    return text.replace(/(?<! {2})\n(?!\n)/g, "  \n");
+}
+export async function getPrimaryAgentNames(client) {
+    const res = await client.app.agents();
+    return (res.data ?? [])
+        .filter((a) => a.mode !== "subagent" && !a.hidden)
+        .map((a) => a.name);
+}
+export async function getAgentModel(client, agentName) {
+    const res = await client.app.agents();
+    const agent = (res.data ?? []).find((a) => a.name === agentName);
+    if (!agent?.model)
+        return null;
+    return { providerID: agent.model.providerID, modelID: agent.model.modelID };
+}
+export async function getDefaultAgentName(client) {
+    const primaryAgents = await getPrimaryAgentNames(client);
+    return primaryAgents[0] ?? "unknown";
+}
+/**
+ * Detect the current agent by inspecting the active session's messages.
+ * Now receives state explicitly instead of calling getState().
+ */
+export async function detectCurrentAgent(state, client) {
+    const defaultAgent = await getDefaultAgentName(client);
+    if (state.activeSessionId) {
+        const res = await client.session.messages({
+            path: { id: state.activeSessionId },
+        });
+        const msgs = res.data ?? [];
+        for (let i = msgs.length - 1; i >= 0; i--) {
+            const info = msgs[i].info;
+            if (info.role === "user") {
+                return info.agent || defaultAgent;
+            }
+        }
+    }
+    return defaultAgent;
+}
+export async function cycleAgentName(state, client, primaryAgents, currentAgent) {
+    if (primaryAgents.length === 0)
+        return null;
+    const resolved = currentAgent ?? (await detectCurrentAgent(state, client));
+    const idx = primaryAgents.indexOf(resolved);
+    return primaryAgents[(idx + 1) % primaryAgents.length];
+}
+// ============ Security Helpers ============
+export function maskSensitiveData(data) {
+    if (data === null || data === undefined)
+        return data;
+    if (typeof data !== "object")
+        return data;
+    const masked = JSON.parse(JSON.stringify(data));
+    const sensitiveFields = ["token", "accessToken", "clientSecret", "appSecret"];
+    function maskObj(obj) {
+        for (const key in obj) {
+            if (sensitiveFields.includes(key)) {
+                const val = obj[key];
+                if (typeof val === "string" && val.length > 6) {
+                    obj[key] =
+                        val.slice(0, 3) + "*".repeat(val.length - 6) + val.slice(-3);
+                }
+                else if (typeof val === "string") {
+                    obj[key] = "*".repeat(val.length);
+                }
+            }
+            else if (typeof obj[key] === "object" && obj[key] !== null) {
+                maskObj(obj[key]);
+            }
+        }
+    }
+    maskObj(masked);
+    return masked;
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "version": "0.2.0",
+  "description": "OpenCode DingTalk Plugin - Remote access via DingTalk enterprise bot",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "opencode-dingtalk": "dist/standalone.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "standalone": "node dist/standalone.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://gitlab.alibaba-inc.com/gaode.search/opencode-dingtalk.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.anpm.alibaba-inc.com"
+  },
+  "keywords": [
+    "opencode-dingtalk",
+    "opencode",
+    "dingtalk",
+    "plugin",
+    "remote",
+    "bot",
+    "钉钉"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@opencode-ai/plugin": "1.1.53",
+    "@opencode-ai/sdk": "1.1.53",
+    "undici": "^6.0.0",
+    "zod": "4.1.8"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.13.9",
+    "husky": "^8.0.3",
+    "jest": "^30.3.0",
+    "lint-staged": "^13.2.3",
+    "prettier": "^3.0.2",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.8.2"
+  },
+  "name": "opencode-dingtalk"
+}