dsh-dingtalk 0.1.0

package/README.md

@@ -0,0 +1,114 @@
+# dsh-dingtalk
+
+DeepSeek Harness 钉钉群机器人通知插件：让 agent 能**单向推送 Markdown / 纯文本消息到钉钉群**。纯插件实现，零核心改动，安装即可用。
+
+纯 Node 实现，**全平台通用**（Windows / macOS / Linux 同一份代码），只依赖 `node:crypto` 与内置 `fetch`，无运行时依赖、无原生二进制。
+
+## 工具一览
+
+| 工具 | 作用 |
+|---|---|
+| `dingtalk_notify` | 向配置的钉钉群发一条 **Markdown** 消息（`title` 标题 + `text` Markdown 正文） |
+| `dingtalk_text` | 向配置的钉钉群发一条 **纯文本** 消息（`content`） |
+
+示例对话：
+
+> 帮我给钉钉群发一条消息：标题「构建完成」，正文「流水线 #123 已通过 ✅」。
+
+## 安装
+
+```sh
+dsh plugin --profile web add dsh-dingtalk
+```
+
+装好后重启 `dsh web`。插件自带空配置，**不会弄崩启动**；配置前调用任何 `dingtalk_*` 工具都会返回明确的中文配置提示。
+
+## 第一步：拿到 webhook 与加签密钥
+
+用钉钉【自定义机器人】方式，**不需要企业应用、不需要管理员权限**：
+
+1. 打开目标钉钉群 → **群设置** → **智能群助手** → **添加机器人** → **自定义（通过 Webhook 接入自定义服务）**
+2. 机器人名称随意，**安全设置勾选「加签」**，完成
+3. 复制两样东西：
+   - **Webhook 地址**：形如 `https://oapi.dingtalk.com/robot/send?access_token=xxxx`
+   - **加签密钥（secret）**：形如 `SECxxxx`（勾选「加签」后才会出现）
+
+> 安全设置推荐只勾选「加签」。如果同时勾选了「自定义关键词」，机器人会校验消息里是否包含关键词——那是钉钉服务端行为，本插件不处理（见「已知限制」）。
+
+## 配置
+
+在你 profile 的 `cordis.patch.yml` 里覆盖 `tool-dingtalk` 行（在 `$DSH_HOME/profiles/<name>/` 下），然后重启：
+
+```yaml
+- id: tool-dingtalk
+  config:
+    webhook: https://oapi.dingtalk.com/robot/send?access_token=你的token
+    secret: SEC你的加签密钥        # 可选，但强烈建议；也可用环境变量 DSH_DINGTALK_SECRET
+```
+
+### 完整配置项
+
+| 字段 | 默认 | 说明 |
+|---|---|---|
+| `webhook` | 必填 | 机器人完整 Webhook 地址（`?access_token=...`） |
+| `secret` | 空 | 加签密钥；省略时回退环境变量 `DSH_DINGTALK_SECRET`。不填=不加签 |
+| `timeoutMs` | `10000` | 请求超时毫秒数（1000–60000） |
+
+### 用环境变量存 secret
+
+不想把密钥写进 YAML 的话，可以只写 `webhook`，然后设置环境变量：
+
+```sh
+# Windows PowerShell
+$env:DSH_DINGTALK_SECRET = "SEC你的加签密钥"
+# 或系统环境变量里加一条 DSH_DINGTALK_SECRET
+```
+
+显式写在 YAML 里的 `secret` 优先于环境变量。
+
+## 安全须知
+
+- **webhook 就是群通知的钥匙**：知道它的人可以往群里发消息。请勿把 `cordis.patch.yml` 提交到任何 Git 仓库；`secret` 更推荐用环境变量 `DSH_DINGTALK_SECRET`。
+- 本插件**只做单向通知**（agent → 钉钉群），不会读取群里任何消息，也没有双向机器人能力。
+- 本插件不做任何联网上报；`secret` 只在内存中用于计算 HMAC 签名，签名拼进 URL 发给钉钉官方接口。
+
+## 加签算法（对照官方）
+
+`secret` 存在时，请求 URL 追加 `timestamp`（毫秒时间戳）与 `sign`：
+
+```text
+stringToSign = timestamp + "
+" + secret
+sign = urlencode(base64(HmacSHA256(secret, stringToSign)))
+```
+
+与本插件 `computeDingTalkSign` 一致，等价于官方 Python 示例的 `urllib.parse.quote_plus(base64(...))`。
+
+## 已知限制（v0.1）
+
+- **仅单向通知**：不支持企业自建应用、不支持接收群消息 / 双向机器人（@机器人 回复等），这些是 v0.2+ 的方向。
+- **不支持自定义关键词校验的自动规避**：如果机器人在钉钉侧勾选了「自定义关键词」，消息必须包含关键词，否则钉钉返回错误（errcode 310000 也可能因此出现）。本插件把 310000 归因于加签，请同时检查关键词设置。
+- **无设置页**：v0.1 是「node 半身」，配置只能走 `cordis.patch.yml`（+ 环境变量）。Web 设置页在 v0.2+。
+- **消息类型**：目前只支持 Markdown（`dingtalk_notify`）与纯文本（`dingtalk_text`）两种；图片/Link/FeedCard/ActionCard 等类型后续再加。
+- **Markdown 渲染**：钉钉机器人 Markdown 语法与标准 Markdown 略有差异（如标题、链接），请按钉钉语法书写。
+
+## 错误码速查
+
+| errcode | 含义 | 建议 |
+|---|---|---|
+| `0` | 成功 | — |
+| `310000` | 加签校验失败（也见上面关键词说明） | 检查 `secret` 是否填对、是否与机器人「加签」设置一致 |
+| `120001` | `access_token` 失效 | 到钉钉群重新复制 webhook 地址，覆盖 `webhook` |
+| 其他 | 服务端错误 | 看返回的 `errmsg` |
+
+## 开发
+
+```sh
+pnpm install
+pnpm run build   # tsc → lib/
+pnpm test        # 构建 + node --test（加签算法/配置解析/客户端封装/注册与中文报错）
+```
+
+## 协议
+
+MIT。这是一个社区插件，与 DeepSeek 官方及钉钉官方无关；`@deepseek-ai/*` 为官方保留命名空间。

package/cordis.patch.yml

@@ -0,0 +1,17 @@
+# dsh-dingtalk: 钉钉群机器人单向通知工具（DeepSeek Harness 插件）。
+#
+# 本行随插件附带【空配置】安装，绝不弄崩启动；配置前调用任何 dingtalk_*
+# 工具都会返回明确的中文配置提示。请在你的 profile 的 cordis.patch.yml 里
+# 覆盖 tool-dingtalk 行（后层覆盖前层），例如：
+#
+#   - id: tool-dingtalk
+#     config:
+#       webhook: https://oapi.dingtalk.com/robot/send?access_token=你的token
+#       secret: SEC你的加签密钥   # 可选；也可用环境变量 DSH_DINGTALK_SECRET
+#
+# 获取方式：钉钉群 → 群设置 → 智能群助手 → 添加机器人 → 自定义（webhook），
+# 复制 webhook 地址；安全设置勾选「加签」，复制加签密钥（secret）。
+- insert:
+    - id: tool-dingtalk
+      name: dsh-dingtalk
+      config: {}

package/lib/client.d.ts

@@ -0,0 +1,34 @@
+import type { DingTalkSendResult } from './types.js';
+export interface FetchLikeResponse {
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+    text(): Promise<string>;
+}
+export type FetchLike = (url: string, init?: Record<string, unknown>) => Promise<FetchLikeResponse>;
+export declare class DingTalkError extends Error {
+    readonly errcode: number | undefined;
+    constructor(message: string, errcode?: number);
+}
+/** 把钉钉 errcode 映射为中文指引（模型与用户都读）。 */
+export declare function dingTalkErrorMessage(errcode: number, errmsg: string): string;
+export interface DingTalkClientOptions {
+    webhook: string;
+    secret?: string;
+    timeoutMs?: number;
+    /** 可注入的 fetch 实现（默认用全局 fetch），便于测试。 */
+    fetchImpl?: FetchLike;
+}
+/** 钉钉自定义机器人 webhook 客户端（单向发送，加签模式）。 */
+export declare class DingTalkClient {
+    private readonly webhook;
+    private readonly secret;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    constructor(options: DingTalkClientOptions);
+    /** 发送 Markdown 消息：{ msgtype: 'markdown', markdown: { title, text } } */
+    sendMarkdown(title: string, text: string): Promise<DingTalkSendResult>;
+    /** 发送纯文本消息：{ msgtype: 'text', text: { content } } */
+    sendText(content: string): Promise<DingTalkSendResult>;
+    private post;
+}

package/lib/client.js

@@ -0,0 +1,82 @@
+import { signedUrl } from './sign.js';
+const defaultFetch = (url, init) => fetch(url, init);
+export class DingTalkError extends Error {
+    errcode;
+    constructor(message, errcode) {
+        super(message);
+        this.name = 'DingTalkError';
+        this.errcode = errcode;
+    }
+}
+/** 把钉钉 errcode 映射为中文指引（模型与用户都读）。 */
+export function dingTalkErrorMessage(errcode, errmsg) {
+    if (errcode === 310000) {
+        return '钉钉返回 310000（加签校验失败）：请检查 secret 加签密钥是否填写正确、是否与机器人「安全设置-加签」一致；若同时勾选了「自定义关键词」，也请确认消息包含关键词。';
+    }
+    if (errcode === 120001) {
+        return '钉钉返回 120001（access_token 失效）：webhook 里的 token 已过期或被重置，请到钉钉群重新复制机器人 webhook 地址，覆盖配置里的 webhook。';
+    }
+    return '钉钉返回错误 ' + errcode + '：' + (errmsg || '未知错误');
+}
+/** 钉钉自定义机器人 webhook 客户端（单向发送，加签模式）。 */
+export class DingTalkClient {
+    webhook;
+    secret;
+    timeoutMs;
+    fetchImpl;
+    constructor(options) {
+        this.webhook = options.webhook;
+        this.secret = options.secret ?? '';
+        this.timeoutMs = options.timeoutMs ?? 10000;
+        this.fetchImpl = options.fetchImpl ?? defaultFetch;
+    }
+    /** 发送 Markdown 消息：{ msgtype: 'markdown', markdown: { title, text } } */
+    async sendMarkdown(title, text) {
+        return this.post({ msgtype: 'markdown', markdown: { title, text } });
+    }
+    /** 发送纯文本消息：{ msgtype: 'text', text: { content } } */
+    async sendText(content) {
+        return this.post({ msgtype: 'text', text: { content } });
+    }
+    async post(payload) {
+        const url = signedUrl(this.webhook, this.secret || undefined);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+            response = await this.fetchImpl(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const hint = /abort/i.test(message) ? '（请求超时）' : '';
+            throw new DingTalkError('钉钉机器人请求失败' + hint + '：' + message);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new DingTalkError('钉钉机器人返回 HTTP ' + response.status + '：' + body.slice(0, 200));
+        }
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch {
+            throw new DingTalkError('钉钉机器人返回非 JSON 响应（HTTP ' + response.status + '）');
+        }
+        const result = body;
+        if (typeof result?.errcode !== 'number') {
+            throw new DingTalkError('钉钉机器人返回格式异常：缺少 errcode');
+        }
+        if (result.errcode !== 0) {
+            throw new DingTalkError(dingTalkErrorMessage(result.errcode, result.errmsg ?? ''), result.errcode);
+        }
+        return result;
+    }
+}

package/lib/config.d.ts

@@ -0,0 +1,21 @@
+export declare const DINGTALK_SECRET_ENV = "DSH_DINGTALK_SECRET";
+export declare const DEFAULT_TIMEOUT_MS = 10000;
+export interface DingTalkConfig {
+    /** 完整 webhook URL（必填），形如 https://oapi.dingtalk.com/robot/send?access_token=XXX */
+    webhook?: string;
+    /** 加签密钥（可选，推荐）。省略时回退环境变量 DSH_DINGTALK_SECRET */
+    secret?: string;
+    /** 请求超时毫秒数，默认 10000（1000–60000） */
+    timeoutMs?: number;
+}
+export interface ResolvedDingTalkConfig {
+    webhook: string;
+    secret: string;
+    timeoutMs: number;
+}
+/**
+ * 解析并校验原始行配置。webhook 缺失时抛出带中文指引的错误（模型与用户都读）。
+ * 只解析、不失败：secret 可选，未配置加签则不加签。
+ */
+export declare function resolveDingTalkConfig(config: DingTalkConfig | undefined): ResolvedDingTalkConfig;
+export declare function clampInt(value: unknown, fallback: number, min: number, max: number): number;

package/lib/config.js

@@ -0,0 +1,25 @@
+export const DINGTALK_SECRET_ENV = 'DSH_DINGTALK_SECRET';
+export const DEFAULT_TIMEOUT_MS = 10000;
+/**
+ * 解析并校验原始行配置。webhook 缺失时抛出带中文指引的错误（模型与用户都读）。
+ * 只解析、不失败：secret 可选，未配置加签则不加签。
+ */
+export function resolveDingTalkConfig(config) {
+    const raw = config ?? {};
+    const webhook = (typeof raw.webhook === 'string' ? raw.webhook : '').trim();
+    const secret = (typeof raw.secret === 'string' ? raw.secret : '').trim() || (process.env[DINGTALK_SECRET_ENV] ?? '').trim();
+    if (webhook === '') {
+        throw new Error('dsh-dingtalk 未配置：webhook（钉钉机器人完整地址）未填写。请在 profile 的 cordis.patch.yml 中覆盖 tool-dingtalk 行并重启（见插件 README）');
+    }
+    return {
+        webhook,
+        secret,
+        timeoutMs: clampInt(raw.timeoutMs, DEFAULT_TIMEOUT_MS, 1000, 60000),
+    };
+}
+export function clampInt(value, fallback, min, max) {
+    const n = typeof value === 'number' ? Math.trunc(value) : fallback;
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.min(max, Math.max(min, n));
+}

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+import { type DingTalkConfig } from './config.js';
+export declare const name = "tool-dingtalk";
+export declare const inject: string[];
+export type Config = DingTalkConfig;
+export declare function apply(ctx: any, config?: Config): void;
+export { resolveDingTalkConfig, DINGTALK_SECRET_ENV, DEFAULT_TIMEOUT_MS, clampInt } from './config.js';
+export { DingTalkClient, DingTalkError, dingTalkErrorMessage } from './client.js';
+export type { FetchLike, FetchLikeResponse, DingTalkClientOptions } from './client.js';
+export { computeDingTalkSign, signedUrl, dingTalkTimestamp } from './sign.js';

package/lib/index.js

@@ -0,0 +1,106 @@
+import { resolveDingTalkConfig } from './config.js';
+import { DingTalkClient } from './client.js';
+export const name = 'tool-dingtalk';
+export const inject = ['tools'];
+/**
+ * 把作者 DSL 映射编译成原生 JSON Schema 对象，作为 defineTool 的
+ * definition.parameters 原样下发。原生 wire 请求会逐字携带该值，塞原始 DSL
+ * 会被模型 API 拒绝（"schema must be a JSON Schema of 'type: object'"）。
+ */
+function compileParameters(spec) {
+    const properties = {};
+    const required = [];
+    for (const [key, prop] of Object.entries(spec)) {
+        if (prop?.required === true)
+            required.push(key);
+        const node = {};
+        if (typeof prop?.type === 'string')
+            node.type = prop.type;
+        if (typeof prop?.description === 'string')
+            node.description = prop.description;
+        properties[key] = node;
+    }
+    return { type: 'object', properties, ...(required.length > 0 ? { required } : {}) };
+}
+const notifySchema = {
+    type: 'object',
+    properties: {
+        ok: { type: 'boolean' },
+        msgtype: { type: 'string' },
+        title: { type: 'string' },
+        errcode: { type: 'integer' },
+        errmsg: { type: 'string' },
+    },
+    additionalProperties: true,
+};
+function oneText(text) {
+    return [{ type: 'text', text }];
+}
+function renderNotify(value) {
+    if (value.msgtype === 'markdown') {
+        return oneText('已通过钉钉机器人发送 Markdown 消息（标题「' + value.title + '」），钉钉返回 errcode=' + value.errcode + '，errmsg=' + value.errmsg);
+    }
+    return oneText('已通过钉钉机器人发送文本消息，钉钉返回 errcode=' + value.errcode + '，errmsg=' + value.errmsg);
+}
+export function apply(ctx, config = {}) {
+    let client = null;
+    let fingerprint = '';
+    const getClient = () => {
+        const resolved = resolveDingTalkConfig(config);
+        const fp = JSON.stringify(resolved);
+        if (client === null || fp !== fingerprint) {
+            client = new DingTalkClient(resolved);
+            fingerprint = fp;
+        }
+        return client;
+    };
+    // 加载期仅提示，绝不弄崩启动；具体细节由各工具的 execute 抛出中文指引。
+    try {
+        getClient();
+    }
+    catch (error) {
+        ctx.logger?.warn?.('[dsh-dingtalk] ' + (error instanceof Error ? error.message : '未配置钉钉机器人'));
+    }
+    ctx.tools.register({
+        name: 'dingtalk_notify',
+        description: '向配置的钉钉群发送一条 Markdown 消息（单向通知）。title 为标题，text 为 Markdown 正文；需先在 profile 的 cordis.patch.yml 配置 webhook（与可选 secret 加签密钥）。',
+        parameters: compileParameters({
+            title: { type: 'string', required: true, description: '消息标题（显示在钉钉卡片顶部）' },
+            text: { type: 'string', required: true, description: 'Markdown 正文内容' },
+        }),
+        output: {
+            schema: notifySchema,
+            render: (_args, value) => renderNotify(value),
+        },
+        async execute(rawArgs) {
+            const args = rawArgs;
+            if (typeof args.title !== 'string' || args.title.trim() === '')
+                throw new Error('title 不能为空');
+            if (typeof args.text !== 'string' || args.text.trim() === '')
+                throw new Error('text 不能为空');
+            const result = await getClient().sendMarkdown(args.title, args.text);
+            return { ok: true, msgtype: 'markdown', title: args.title, errcode: result.errcode, errmsg: result.errmsg };
+        },
+    });
+    ctx.tools.register({
+        name: 'dingtalk_text',
+        description: '向配置的钉钉群发送一条纯文本消息（单向通知）。',
+        parameters: compileParameters({
+            content: { type: 'string', required: true, description: '纯文本消息内容' },
+        }),
+        output: {
+            schema: notifySchema,
+            render: (_args, value) => renderNotify(value),
+        },
+        async execute(rawArgs) {
+            const args = rawArgs;
+            if (typeof args.content !== 'string' || args.content.trim() === '')
+                throw new Error('content 不能为空');
+            const result = await getClient().sendText(args.content);
+            return { ok: true, msgtype: 'text', title: '', errcode: result.errcode, errmsg: result.errmsg };
+        },
+    });
+}
+export { resolveDingTalkConfig, DINGTALK_SECRET_ENV, DEFAULT_TIMEOUT_MS, clampInt } from './config.js';
+export { DingTalkClient, DingTalkError, dingTalkErrorMessage } from './client.js';
+export { computeDingTalkSign, signedUrl, dingTalkTimestamp } from './sign.js';

package/lib/sign.d.ts

@@ -0,0 +1,15 @@
+/** 当前毫秒时间戳（字符串）。 */
+export declare function dingTalkTimestamp(now?: number): string;
+/**
+ * 钉钉自定义机器人「加签」安全模式的签名。
+ *
+ * 官方算法：
+ *   stringToSign = timestamp + "\n" + secret
+ *   sign = urlencode(base64(HmacSHA256(secret, stringToSign)))
+ *
+ * 与官方 Python 示例的 urllib.parse.quote_plus(base64(...)) 等价：base64 输出
+ * 不含空格，只需编码 '+' '/' '=' 三个字符，encodeURIComponent 正好覆盖。
+ */
+export declare function computeDingTalkSign(secret: string, timestamp: string): string;
+/** 在 webhook 地址上追加 timestamp 与 sign 参数（secret 为空则原样返回）。 */
+export declare function signedUrl(webhook: string, secret: string | undefined, timestamp?: string): string;

package/lib/sign.js

@@ -0,0 +1,29 @@
+import { createHmac } from 'node:crypto';
+/** 当前毫秒时间戳（字符串）。 */
+export function dingTalkTimestamp(now = Date.now()) {
+    return String(Math.floor(now));
+}
+/**
+ * 钉钉自定义机器人「加签」安全模式的签名。
+ *
+ * 官方算法：
+ *   stringToSign = timestamp + "\n" + secret
+ *   sign = urlencode(base64(HmacSHA256(secret, stringToSign)))
+ *
+ * 与官方 Python 示例的 urllib.parse.quote_plus(base64(...)) 等价：base64 输出
+ * 不含空格，只需编码 '+' '/' '=' 三个字符，encodeURIComponent 正好覆盖。
+ */
+export function computeDingTalkSign(secret, timestamp) {
+    const stringToSign = timestamp + '\n' + secret;
+    const hmac = createHmac('sha256', secret).update(stringToSign, 'utf8').digest();
+    return encodeURIComponent(hmac.toString('base64'));
+}
+/** 在 webhook 地址上追加 timestamp 与 sign 参数（secret 为空则原样返回）。 */
+export function signedUrl(webhook, secret, timestamp) {
+    if (!secret)
+        return webhook;
+    const ts = timestamp ?? dingTalkTimestamp();
+    const sign = computeDingTalkSign(secret, ts);
+    const sep = webhook.includes('?') ? '&' : '?';
+    return webhook + sep + 'timestamp=' + ts + '&sign=' + sign;
+}

package/lib/types.d.ts

@@ -0,0 +1,19 @@
+export interface DingTalkNotifyArgs {
+    title: string;
+    text: string;
+}
+export interface DingTalkTextArgs {
+    content: string;
+}
+export interface DingTalkNotifyResult {
+    ok: boolean;
+    msgtype: 'markdown' | 'text';
+    title: string;
+    errcode: number;
+    errmsg: string;
+}
+/** 钉钉 send 接口的原始返回（成功时 errcode === 0）。 */
+export interface DingTalkSendResult {
+    errcode: number;
+    errmsg: string;
+}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "dsh-dingtalk",
+  "version": "0.1.0",
+  "description": "钉钉群机器人单向通知工具（DeepSeek Harness 插件）：agent 推送 Markdown / 纯文本消息到钉钉群，支持加签安全模式。",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "prepublishOnly": "pnpm run build",
+    "test": "pnpm run build && node --test \"test/*.test.mjs\""
+  },
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "dsh",
+    "dingtalk",
+    "dingtalk-robot",
+    "webhook"
+  ],
+  "author": "dsh-community",
+  "license": "MIT",
+  "packageManager": "pnpm@11.7.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^5.7.3"
+  },
+  "repository": {
+    "url": "https://github.com/STARDUSTLC666/dsh-dingtalk",
+    "type": "git"
+  },
+  "bugs": {
+    "url": "https://github.com/STARDUSTLC666/dsh-dingtalk/issues"
+  },
+  "homepage": "https://github.com/STARDUSTLC666/dsh-dingtalk#readme"
+}