@zhin.js/adapter-kook 5.0.1 → 5.0.3

package/lib/protocol.js

@@ -0,0 +1,279 @@
+/**
+ * KOOK protocol helpers — no legacy Adapter/Endpoint / segment-mapper.
+ * Canonicalization is owned by gateway/core before endpoint.send.
+ */
+import { createDecipheriv, timingSafeEqual } from 'node:crypto';
+import { inflateSync } from 'node:zlib';
+import { pickCredential } from '@zhin.js/adapter';
+export var KookPermission;
+(function (KookPermission) {
+    KookPermission[KookPermission["Normal"] = 1] = "Normal";
+    KookPermission[KookPermission["Admin"] = 2] = "Admin";
+    KookPermission[KookPermission["Owner"] = 4] = "Owner";
+    KookPermission[KookPermission["ChannelAdmin"] = 5] = "ChannelAdmin";
+})(KookPermission || (KookPermission = {}));
+export function resolveKookConfig(config = {}) {
+    const entry = config.endpoints?.find((item) => item.context === 'kook' || !item.context);
+    const token = pickCredential(config.token, entry?.token, process.env.KOOK_TOKEN, process.env.KOOK_BOT_TOKEN);
+    if (!token) {
+        throw new TypeError('KOOK adapter requires token (plugins.<key>.token or endpoints with context: kook)');
+    }
+    const name = (typeof config.name === 'string' && config.name)
+        || (typeof entry?.name === 'string' && entry.name)
+        || process.env.KOOK_BOT_NAME
+        || 'kook-bot';
+    const connection = config.connection
+        ?? entry?.connection
+        ?? 'websocket';
+    if (connection === 'webhook') {
+        const verifyToken = (typeof config.verify_token === 'string' && config.verify_token)
+            || (typeof entry?.verify_token === 'string' && entry.verify_token)
+            || process.env.KOOK_VERIFY_TOKEN
+            || '';
+        if (!verifyToken) {
+            throw new TypeError('KOOK webhook mode requires verify_token (plugins.<key>.verify_token or KOOK_VERIFY_TOKEN)');
+        }
+        const encryptKey = config.encrypt_key ?? entry?.encrypt_key ?? process.env.KOOK_ENCRYPT_KEY;
+        return {
+            context: 'kook',
+            connection: 'webhook',
+            name,
+            token,
+            webhookPath: normalizeWebhookPath(config.webhookPath ?? entry?.webhookPath ?? process.env.KOOK_WEBHOOK_PATH ?? '/kook/webhook'),
+            verifyToken,
+            encryptKey: typeof encryptKey === 'string' && encryptKey ? encryptKey : undefined,
+            ignore: config.ignore ?? entry?.ignore ?? 'bot',
+            logLevel: config.logLevel ?? entry?.logLevel ?? 'info',
+        };
+    }
+    return {
+        context: 'kook',
+        connection: 'websocket',
+        name,
+        token,
+        data_dir: config.data_dir ?? entry?.data_dir,
+        timeout: config.timeout ?? entry?.timeout ?? 10_000,
+        max_retry: config.max_retry ?? entry?.max_retry ?? 3,
+        ignore: config.ignore ?? entry?.ignore ?? 'bot',
+        logLevel: config.logLevel ?? entry?.logLevel ?? 'info',
+    };
+}
+/**
+ * Gateway reply target：`private:uid` / `channel:cid`，便于 send() 还原 API。
+ */
+export function formatInboundTarget(msg) {
+    return `${msg.channelKind}:${msg.channelId}`;
+}
+export function parseSendTarget(target) {
+    const sep = target.indexOf(':');
+    if (sep <= 0) {
+        return { kind: 'channel', id: target };
+    }
+    const head = target.slice(0, sep);
+    const rest = target.slice(sep + 1);
+    if (head === 'private')
+        return { kind: 'private', id: rest };
+    if (head === 'channel' || head === 'group')
+        return { kind: 'channel', id: rest };
+    return { kind: 'channel', id: target };
+}
+export function senderDisplayName(msg) {
+    return msg.authorName || msg.authorId;
+}
+/** Build inbound text for MessageGateway.receive */
+export function formatInboundContent(msg) {
+    const text = (msg.content || msg.rawMessage || '').trim();
+    return text || '(Empty message)';
+}
+/**
+ * KOOK @ 用户标记为 `(met)<userId>(met)`；content 含 `(met)<botId>(met)` 时视为 @ 机器人。
+ * botId 取 client 缓存的 self_id（/me 类接口），拿不到则不标注。
+ */
+export function isKookBotMentioned(msg, selfId) {
+    if (!selfId)
+        return false;
+    const marker = `(met)${selfId}(met)`;
+    return (msg.content || '').includes(marker) || (msg.rawMessage || '').includes(marker);
+}
+/**
+ * Wire-encode an already-rendered outbound payload into KOOK KMarkdown.
+ * Segment canonicalization is intentionally not done here.
+ */
+export function formatOutboundKmarkdown(payload) {
+    if (typeof payload === 'string')
+        return payload;
+    const segments = Array.isArray(payload)
+        ? payload
+        : payload && typeof payload === 'object' && 'type' in payload
+            ? [payload]
+            : [];
+    if (segments.length === 0) {
+        return payload == null
+            ? ''
+            : typeof payload === 'object'
+                ? JSON.stringify(payload)
+                : String(payload);
+    }
+    return segments
+        .map((item) => {
+        if (typeof item === 'string')
+            return item;
+        const data = item.data ?? {};
+        switch (item.type) {
+            case 'text':
+                return String(data.text ?? data.content ?? '');
+            case 'at': {
+                const id = String(data.user_id ?? data.qq ?? data.id ?? '');
+                return id === 'all' ? '(met)all(met)' : `(met)${id}(met)`;
+            }
+            case 'image':
+                return `![${String(data.alt || '图片')}](${String(data.url || data.file || '')})`;
+            case 'face':
+                return `(emj)${String(data.name || 'emoji')}(emj)[${String(data.id ?? '')}]`;
+            case 'link':
+                return `[${String(data.text || data.url || '')}](${String(data.url || '')})`;
+            case 'video':
+                return `[视频](${String(data.url || data.file || '')})`;
+            case 'audio':
+                return `[音频](${String(data.url || data.file || '')})`;
+            case 'file':
+                return `[文件: ${String(data.name || '未命名')}](${String(data.url || data.file || '')})`;
+            case 'bold':
+                return `**${String(data.text ?? '')}**`;
+            case 'italic':
+                return `*${String(data.text ?? '')}*`;
+            case 'code':
+                return `\`${String(data.text ?? '')}\``;
+            case 'code_block':
+                return `\`\`\`${String(data.language || '')}\n${String(data.text ?? '')}\n\`\`\``;
+            case 'reply':
+                return '';
+            default:
+                return data.text != null ? String(data.text) : '';
+        }
+    })
+        .filter(Boolean)
+        .join('');
+}
+export function normalizeWebhookPath(path) {
+    const trimmed = path.trim() || '/kook/webhook';
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+}
+export async function readTextBody(request, options = {}) {
+    const limit = options.limit ?? 1_048_576;
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limit) {
+            request.destroy();
+            throw new Error(`Request body exceeds ${limit} bytes`);
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+export async function readRequestBody(request, options = {}) {
+    const limit = options.limit ?? 1_048_576;
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limit) {
+            request.destroy();
+            throw new Error(`Request body exceeds ${limit} bytes`);
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks);
+}
+export function padKookEncryptKey(key) {
+    const buf = Buffer.alloc(32, 0);
+    Buffer.from(key, 'utf8').copy(buf, 0, 0, Math.min(32, Buffer.byteLength(key, 'utf8')));
+    return buf;
+}
+export function decryptKookWebhookPayload(encrypted, encryptKey) {
+    const decoded = Buffer.from(encrypted, 'base64');
+    const iv = decoded.subarray(0, 16);
+    const ciphertext = decoded.subarray(16);
+    const decipher = createDecipheriv('aes-256-cbc', padKookEncryptKey(encryptKey), iv);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+export function parseKookWebhookBody(rawBody, encryptKey) {
+    let text = rawBody.toString('utf8').trim();
+    if (!text.startsWith('{')) {
+        text = inflateSync(rawBody).toString('utf8');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new TypeError('Invalid KOOK webhook JSON body');
+    }
+    if (parsed.encrypt) {
+        if (!encryptKey) {
+            throw new TypeError('KOOK webhook payload is encrypted but encrypt_key is not configured');
+        }
+        const decrypted = decryptKookWebhookPayload(parsed.encrypt, encryptKey);
+        // 在字节层面判断：明文 JSON 以 '{' 开头，否则按 zlib 压缩数据处理。
+        // 不能先 toString('utf8') 再转回 Buffer —— 压缩二进制会被替换字符损坏。
+        let offset = 0;
+        while (offset < decrypted.length
+            && (decrypted[offset] === 0x20 || decrypted[offset] === 0x09
+                || decrypted[offset] === 0x0a || decrypted[offset] === 0x0d)) {
+            offset += 1;
+        }
+        const decryptedText = decrypted[offset] === 0x7b // '{'
+            ? decrypted.toString('utf8')
+            : inflateSync(decrypted).toString('utf8');
+        parsed = JSON.parse(decryptedText);
+    }
+    return parsed;
+}
+export function isKookWebhookChallenge(event) {
+    return event.type === 255 && event.channel_type === 'WEBHOOK_CHALLENGE';
+}
+export function verifyKookWebhookToken(expected, actual) {
+    if (!actual)
+        return false;
+    const left = Buffer.from(expected, 'utf8');
+    const right = Buffer.from(actual, 'utf8');
+    if (left.length !== right.length)
+        return false;
+    return timingSafeEqual(left, right);
+}
+export function normalizeKookWebhookEvent(event, options = {}) {
+    if (isKookWebhookChallenge(event))
+        return null;
+    if (event.msg_id == null || event.author_id == null)
+        return null;
+    const authorBot = event.extra?.author?.bot === true;
+    if (authorBot && options.ignore === 'bot')
+        return null;
+    if (options.selfId && String(event.author_id) === options.selfId && options.ignore === 'self') {
+        return null;
+    }
+    const channelKind = event.channel_type === 'GROUP' ? 'channel' : 'private';
+    const channelId = channelKind === 'channel'
+        ? String(event.target_id ?? '')
+        : String(event.author_id);
+    if (!channelId)
+        return null;
+    return {
+        id: String(event.msg_id),
+        content: event.content ?? '',
+        channelKind,
+        channelId,
+        authorId: String(event.author_id),
+        authorName: event.extra?.author?.username
+            || event.extra?.author?.id
+            || String(event.author_id),
+        authorBot,
+        authorRoles: event.extra?.author?.roles,
+        timestamp: event.msg_timestamp ?? Date.now(),
+        guildId: event.extra?.guild_id,
+    };
+}

package/lib/webhook.d.ts

@@ -0,0 +1,15 @@
+/**
+ * KOOK webhook HTTP: verify → parse → admit.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { HttpHost, HttpRouteRegistration } from '@zhin.js/host-http';
+import { type KookInboundMessage, type ResolvedKookWebhookConfig } from './protocol.js';
+export interface KookWebhookHandler {
+    readonly config: ResolvedKookWebhookConfig;
+    readonly isOpen: boolean;
+    readonly selfId?: string;
+    admit(msg: KookInboundMessage): void;
+    checkAndRememberSn(sn: number): boolean;
+}
+export declare function registerKookWebhookRoutes(http: HttpHost, handler: KookWebhookHandler): HttpRouteRegistration[];
+export declare function handleKookWebhookRequest(request: IncomingMessage, response: ServerResponse, handler: KookWebhookHandler): Promise<void>;

package/lib/webhook.js

@@ -0,0 +1,76 @@
+import { formatCompact, getLogger } from '@zhin.js/logger';
+import { isKookWebhookChallenge, normalizeKookWebhookEvent, parseKookWebhookBody, readRequestBody, verifyKookWebhookToken, } from './protocol.js';
+const logger = getLogger('kook');
+export function registerKookWebhookRoutes(http, handler) {
+    const path = handler.config.webhookPath;
+    return [
+        http.route('POST', path, async (request, response) => {
+            await handleKookWebhookRequest(request, response, handler);
+        }, { summary: 'KOOK webhook callback', tags: ['kook'] }),
+    ];
+}
+export async function handleKookWebhookRequest(request, response, handler) {
+    try {
+        const rawBody = await readRequestBody(request);
+        let frame;
+        try {
+            frame = parseKookWebhookBody(rawBody, handler.config.encryptKey);
+        }
+        catch (error) {
+            logger.warn(formatCompact({
+                op: 'kook_webhook',
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+            response.writeHead(400, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'Invalid webhook payload' }));
+            return;
+        }
+        const event = frame.d;
+        if (!event || typeof event !== 'object') {
+            response.writeHead(200, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'OK' }));
+            return;
+        }
+        if (isKookWebhookChallenge(event)) {
+            if (!verifyKookWebhookToken(handler.config.verifyToken, event.verify_token)) {
+                response.writeHead(403, { 'Content-Type': 'application/json' });
+                response.end(JSON.stringify({ message: 'Invalid verify_token' }));
+                return;
+            }
+            response.writeHead(200, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ challenge: event.challenge ?? '' }));
+            return;
+        }
+        if (!verifyKookWebhookToken(handler.config.verifyToken, event.verify_token)) {
+            response.writeHead(403, { 'Content-Type': 'application/json' });
+            response.end(JSON.stringify({ message: 'Invalid verify_token' }));
+            return;
+        }
+        if (frame.sn != null) {
+            if (!handler.checkAndRememberSn(frame.sn)) {
+                response.writeHead(200, { 'Content-Type': 'application/json' });
+                response.end(JSON.stringify({ message: 'OK' }));
+                return;
+            }
+        }
+        if (handler.isOpen) {
+            handleKookWebhookEvent(event, handler);
+        }
+        response.writeHead(200, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify({ message: 'OK' }));
+    }
+    catch (error) {
+        logger.error('KOOK webhook error:', error);
+        response.writeHead(200, { 'Content-Type': 'application/json' });
+        response.end(JSON.stringify({ message: 'OK' }));
+    }
+}
+function handleKookWebhookEvent(event, handler) {
+    const msg = normalizeKookWebhookEvent(event, {
+        ignore: handler.config.ignore,
+        selfId: handler.selfId,
+    });
+    if (msg)
+        handler.admit(msg);
+}

package/lib/ws.d.ts

@@ -0,0 +1,42 @@
+import { type KookInboundMessage, type ResolvedKookConfig, type ResolvedKookWebhookConfig, type ResolvedKookWebsocketConfig } from './protocol.js';
+/** Minimal client surface used by the endpoint (real kook-client or test mock). */
+export interface KookClientTransport {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    on(event: string, listener: (...args: unknown[]) => void): void;
+    removeAllListeners(): void;
+    sendChannelMsg(channelId: string, message: string): Promise<{
+        msg_id?: string | number;
+    }>;
+    sendPrivateMsg(userId: string, message: string): Promise<{
+        msg_id?: string | number;
+    }>;
+    pickGuild(guildId: string): {
+        kick(userId: string): Promise<boolean>;
+        getRoleList(): Promise<Array<{
+            role_id: string | number;
+            name: string;
+            color?: number;
+            position?: number;
+            permissions?: unknown;
+        }>>;
+        createRole(name: string): Promise<{
+            role_id: string | number;
+            name: string;
+        }>;
+        deleteRole(roleId: string): Promise<boolean>;
+    };
+    pickGuildMember(guildId: string, userId: string): {
+        addToBlackList(remark?: string, delMsgDays?: number): Promise<boolean>;
+        removeFromBlackList(): Promise<boolean>;
+        grant(roleId: string): Promise<boolean>;
+        revoke(roleId: string): Promise<boolean>;
+        setNickname(nickname: string): Promise<boolean>;
+    };
+    getGuildUserList?(guildId: string, channelId?: string): Promise<unknown[]>;
+    self_id?: string | number;
+}
+export type CreateKookClient = (config: ResolvedKookConfig) => KookClientTransport;
+export declare function normalizeKookMessage(raw: unknown): KookInboundMessage | null;
+export declare function defaultCreateClient(config: ResolvedKookWebsocketConfig): KookClientTransport;
+export declare function defaultCreateWebhookClient(config: ResolvedKookWebhookConfig): KookClientTransport;

package/lib/ws.js

@@ -0,0 +1,63 @@
+/**
+ * KOOK WebSocket transport: kook-client wrapper and inbound message normalization.
+ */
+import path from 'node:path';
+import { Client } from 'kook-client';
+export function normalizeKookMessage(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const msg = raw;
+    if (msg.message_id == null || msg.author_id == null)
+        return null;
+    const channelKind = msg.message_type === 'channel' ? 'channel' : 'private';
+    const channelId = channelKind === 'channel'
+        ? String(msg.channel_id ?? '')
+        : String(msg.author_id);
+    if (!channelId)
+        return null;
+    const textParts = [];
+    for (const seg of msg.message ?? []) {
+        if (seg.type === 'text' || seg.type === 'markdown') {
+            if (seg.text)
+                textParts.push(seg.text);
+        }
+    }
+    const content = textParts.join('') || msg.raw_message || '';
+    return {
+        id: String(msg.message_id),
+        content,
+        channelKind,
+        channelId,
+        authorId: String(msg.author_id),
+        authorName: msg.author?.info?.nickname
+            || msg.author?.info?.username
+            || String(msg.author_id),
+        authorBot: msg.author?.bot === true || msg.author?.info?.bot === true,
+        authorRoles: msg.author?.info?.roles ?? msg.author?.roles,
+        timestamp: msg.timestamp ?? Date.now(),
+        guildId: msg.channel?.info?.guild_id,
+        rawMessage: msg.raw_message,
+    };
+}
+export function defaultCreateClient(config) {
+    return new Client({
+        token: config.token,
+        mode: 'websocket',
+        data_dir: config.data_dir || path.join(process.cwd(), 'data', 'kook'),
+        timeout: config.timeout,
+        max_retry: config.max_retry,
+        ignore: config.ignore,
+        logLevel: config.logLevel,
+    });
+}
+export function defaultCreateWebhookClient(config) {
+    return new Client({
+        token: config.token,
+        mode: 'webhook',
+        data_dir: path.join(process.cwd(), 'data', 'kook'),
+        timeout: 10_000,
+        max_retry: 3,
+        ignore: config.ignore,
+        logLevel: config.logLevel,
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zhin.js/adapter-kook",
-  "version": "5.0.1",
-  "description": "Zhin.js adapter for KOOK (开黑啦)",
+  "version": "5.0.3",
+  "description": "Zhin.js KOOK adapter for Plugin Runtime (WebSocket gateway or Webhook)",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -33,49 +33,49 @@
     "directory": "plugins/adapters/kook"
   },
   "dependencies": {
-    "kook-client": "^1.0.4"
-  },
-  "devDependencies": {
-    "@types/react": "^19.2.17",
-    "@types/react-dom": "^19.2.3",
-    "lucide-react": "^1.22.0",
-    "typescript": "^6.0.3",
-    "@zhin.js/cli": "1.0.92",
-    "@zhin.js/client": "2.0.4",
-    "@zhin.js/contract": "1.0.2",
-    "@zhin.js/host-api": "2.0.4",
-    "@zhin.js/host-router": "2.0.2",
-    "zhin.js": "4.1.1",
-    "@zhin.js/logger": "1.0.73"
+    "kook-client": "^1.0.4",
+    "@zhin.js/adapter": "1.0.1",
+    "@zhin.js/core": "1.3.5",
+    "@zhin.js/host-http": "1.0.1",
+    "@zhin.js/logger": "1.0.75",
+    "@zhin.js/plugin-runtime": "1.0.1"
   },
   "peerDependencies": {
-    "@zhin.js/client": "2.0.4",
-    "@zhin.js/host-api": "2.0.4",
-    "@zhin.js/contract": "1.0.2",
-    "@zhin.js/logger": "1.0.73",
-    "@zhin.js/host-router": "2.0.2",
-    "zhin.js": "4.1.1"
+    "zod": "^4.0.0",
+    "@zhin.js/adapter": "1.0.1",
+    "@zhin.js/agent": "1.0.4",
+    "@zhin.js/core": "1.3.5",
+    "@zhin.js/plugin-runtime": "1.0.1",
+    "zhin.js": "4.1.3"
   },
   "peerDependenciesMeta": {
-    "@zhin.js/client": {
+    "zhin.js": {
       "optional": true
     },
-    "@zhin.js/host-router": {
+    "@zhin.js/agent": {
       "optional": true
     },
-    "@zhin.js/host-api": {
+    "zod": {
       "optional": true
     }
   },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
+    "zod": "^4.4.3",
+    "@zhin.js/agent": "1.0.4",
+    "@zhin.js/host-http": "1.0.1",
+    "zhin.js": "4.1.3"
+  },
   "files": [
+    "adapters",
+    "plugin.ts",
+    "schema.json",
     "src",
     "lib",
-    "client",
-    "dist",
-    "skills",
-    "plugin.yml",
+    "agent",
     "README.md",
-    "node",
     "CHANGELOG.md"
   ],
   "publishConfig": {
@@ -85,9 +85,23 @@
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },
+  "zhin": {
+    "protocol": 1,
+    "type": "plugin",
+    "entry": "./plugin.ts",
+    "engine": "^1.0.0",
+    "runtime": "trusted",
+    "features": [
+      {
+        "package": "@zhin.js/adapter",
+        "api": "^1.0.0"
+      }
+    ],
+    "plugins": []
+  },
   "scripts": {
-    "build": "zhin build",
-    "clean": "rimraf lib dist",
-    "build:node": "tsc"
+    "build": "tsc",
+    "clean": "rimraf lib",
+    "test": "NODE_OPTIONS=--experimental-strip-types vitest run --root ../../.. plugins/adapters/kook/tests"
   }
 }

package/plugin.ts

@@ -0,0 +1,13 @@
+import { definePlugin } from '@zhin.js/plugin-runtime';
+import { registerKookPlatformPermitChecker } from './src/platform-permit.js';
+
+export default definePlugin({
+  name: 'kook',
+  metadata: {
+    displayName: 'KOOK WebSocket Adapter',
+  },
+  setup() {
+    // 平台权限门禁：guild_owner / guild_admin / channel_admin 等（agent 工具 platformPermit）
+    return registerKookPlatformPermitChecker();
+  },
+});

package/schema.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string",
+      "default": "kook-bot"
+    },
+    "token": {
+      "type": "string"
+    },
+    "connection": {
+      "type": "string",
+      "enum": ["websocket", "webhook"],
+      "default": "websocket",
+      "description": "WebSocket gateway (default). webhook requires httpHostToken, verify_token, and a public HTTPS callback URL."
+    },
+    "webhookPath": {
+      "type": "string",
+      "default": "/kook/webhook",
+      "description": "POST path registered via httpHostToken when connection is webhook."
+    },
+    "verify_token": {
+      "type": "string",
+      "description": "KOOK developer console verify token (required for webhook mode)."
+    },
+    "encrypt_key": {
+      "type": "string",
+      "description": "Optional Encrypt Key when message encryption is enabled in KOOK console."
+    },
+    "data_dir": {
+      "type": "string"
+    },
+    "timeout": {
+      "type": "number",
+      "default": 10000
+    },
+    "max_retry": {
+      "type": "number",
+      "default": 3
+    },
+    "ignore": {
+      "type": "string",
+      "enum": ["bot", "self"],
+      "default": "bot"
+    },
+    "logLevel": {
+      "type": "string",
+      "enum": ["trace", "debug", "info", "warn", "error", "fatal", "mark", "off"],
+      "default": "info"
+    }
+  },
+  "required": ["token"]
+}