ddchat 0.3.0 → 0.4.1

package/src/inbound.js

@@ -0,0 +1,363 @@
+import { randomUUID } from "node:crypto";
+import { DDCHAT_CHANNEL_ID } from "./constants.js";
+import { resolveDdchatOutboundMediaFields } from "./outbound.js";
+import { getDdchatState, getDdchatWsRuntime } from "./runtime.js";
+import { listDdchatAccountIds, resolveDdchatAccount, resolveDdchatMediaMaxBytes } from "./types.js";
+const DEFAULT_WEBHOOK_BODY_MAX_BYTES = 10 * 1024 * 1024;
+function parseBodyLike(raw) {
+    if (!raw) {
+        return {};
+    }
+    if (typeof raw === "object" && !Buffer.isBuffer(raw)) {
+        return raw;
+    }
+    const text = Buffer.isBuffer(raw) ? raw.toString("utf-8") : String(raw);
+    if (!text.trim()) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === "object" && parsed ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+async function readRawBodyFromStream(req, maxBytes) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += buffer.length;
+        if (totalBytes > maxBytes) {
+            throw new Error("webhook body too large");
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+}
+async function readBody(req, maxBytes = DEFAULT_WEBHOOK_BODY_MAX_BYTES) {
+    const direct = req.rawBody ?? req.body;
+    if (direct !== undefined) {
+        if (Buffer.isBuffer(direct) && direct.length > maxBytes) {
+            throw new Error("webhook body too large");
+        }
+        if (typeof direct === "string" && Buffer.byteLength(direct, "utf-8") > maxBytes) {
+            throw new Error("webhook body too large");
+        }
+        return parseBodyLike(direct);
+    }
+    const rawText = await readRawBodyFromStream(req, maxBytes);
+    return parseBodyLike(rawText);
+}
+function resolveInboundIdentity(body) {
+    const messageId = String(body.messageId ?? "").trim();
+    const chatType = body.chatType === "group" ? "group" : "direct";
+    const userId = String(body.userId ?? "").trim();
+    const groupId = String(body.groupId ?? "").trim();
+    if (!messageId) {
+        throw new Error("missing messageId");
+    }
+    if (!userId) {
+        throw new Error("missing userId");
+    }
+    if (chatType === "group" && !groupId) {
+        throw new Error("missing groupId for group chatType");
+    }
+    return {
+        messageId,
+        chatType,
+        userId,
+        groupId: groupId || undefined,
+    };
+}
+function createDdchatMessageId(prefix) {
+    return `${prefix}-${randomUUID()}`;
+}
+function estimateBase64DecodedBytes(input) {
+    const normalized = input.replace(/\s/g, "");
+    const padding = normalized.endsWith("==") ? 2 : normalized.endsWith("=") ? 1 : 0;
+    return Math.floor((normalized.length * 3) / 4) - padding;
+}
+function toInboundFiles(body) {
+    if (Array.isArray(body.files) && body.files.length > 0) {
+        return body.files;
+    }
+    if (body.mediaUrl) {
+        return [
+            {
+                name: body.mediaName,
+                type: body.mediaType,
+                url: body.mediaUrl,
+            },
+        ];
+    }
+    return [];
+}
+async function resolveInboundMedia(params) {
+    const out = [];
+    const maxBytes = resolveDdchatMediaMaxBytes(params.cfg);
+    for (const file of params.files) {
+        const name = typeof file.name === "string" ? file.name : undefined;
+        const mediaType = (typeof file.type === "string" && file.type.trim()) ||
+            (typeof file.mimeType === "string" && file.mimeType.trim()) ||
+            undefined;
+        const base64 = typeof file.base64 === "string" ? file.base64.trim() : "";
+        const url = typeof file.url === "string" ? file.url.trim() : "";
+        try {
+            let buffer;
+            let contentType = mediaType;
+            if (base64) {
+                if (maxBytes && estimateBase64DecodedBytes(base64) > maxBytes) {
+                    throw new Error("media exceeds maximum size");
+                }
+                buffer = Buffer.from(base64, "base64");
+            }
+            else if (url) {
+                const fetched = await params.channelRuntime.media.fetchRemoteMedia({
+                    url,
+                    maxBytes,
+                });
+                buffer = fetched.buffer;
+                contentType = fetched.contentType ?? contentType;
+            }
+            else {
+                continue;
+            }
+            const saved = await params.channelRuntime.media.saveMediaBuffer(buffer, contentType, "inbound/ddchat", maxBytes, name);
+            out.push({
+                path: saved.path,
+                contentType: saved.contentType ?? contentType,
+            });
+        }
+        catch (error) {
+            params.logInfo?.(`ddchat media parse failed: ${String(error)}`);
+        }
+    }
+    return out;
+}
+function inferBodyFromMedia(mediaList) {
+    const firstType = mediaList[0]?.contentType;
+    if (!firstType) {
+        return "<media:file>";
+    }
+    if (firstType.startsWith("image/")) {
+        return "<media:image>";
+    }
+    if (firstType.startsWith("audio/")) {
+        return "<media:audio>";
+    }
+    if (firstType.startsWith("video/")) {
+        return "<media:video>";
+    }
+    return "<media:file>";
+}
+function buildLocalAgentMediaPayload(mediaList) {
+    const first = mediaList[0];
+    const mediaPaths = mediaList.map((media) => media.path);
+    const mediaTypes = mediaList.map((media) => media.contentType).filter(Boolean);
+    return {
+        MediaPath: first?.path,
+        MediaType: first?.contentType ?? undefined,
+        MediaUrl: first?.path,
+        MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+    };
+}
+function collectWebhookRoutes(cfg) {
+    const byPath = new Map();
+    const add = (path, accountId) => {
+        const accounts = byPath.get(path) ?? new Set();
+        accounts.add(accountId);
+        byPath.set(path, accounts);
+    };
+    byPath.set("/ddchat/webhook", new Set());
+    for (const accountId of listDdchatAccountIds(cfg)) {
+        const account = resolveDdchatAccount(cfg, accountId);
+        add(account.webhookPath ?? "/ddchat/webhook", account.accountId);
+    }
+    return Array.from(byPath.entries()).map(([path, accounts]) => {
+        const accountIds = Array.from(accounts);
+        return {
+            path,
+            fallbackAccountId: accountIds.length === 1 ? accountIds[0] : undefined,
+        };
+    });
+}
+export function registerDdchatWebhook(api) {
+    const cfg = api.runtime.config.loadConfig();
+    for (const route of collectWebhookRoutes(cfg)) {
+        api.registerHttpRoute({
+            path: route.path,
+            auth: "plugin",
+            handler: async (req, res) => {
+                try {
+                    const currentCfg = api.runtime.config.loadConfig();
+                    const body = await readBody(req);
+                    const result = await processDdchatInboundWithChannelRuntime({
+                        channelRuntime: api.runtime.channel,
+                        cfg: currentCfg,
+                        body,
+                        fallbackAccountId: route.fallbackAccountId,
+                        source: "webhook",
+                        logInfo: (message) => api.runtime.logging.getChildLogger({ module: "ddchat-inbound" }).info(message),
+                    });
+                    res.statusCode = 200;
+                    res.setHeader("Content-Type", "application/json; charset=utf-8");
+                    res.end(JSON.stringify(result));
+                }
+                catch (error) {
+                    res.statusCode = 400;
+                    res.setHeader("Content-Type", "text/plain; charset=utf-8");
+                    res.end(error instanceof Error ? error.message : "invalid request");
+                }
+                return true;
+            },
+        });
+    }
+}
+export async function processDdchatInboundWithChannelRuntime(params) {
+    const body = parseBodyLike(params.body);
+    const accountId = String(body.accountId ?? params.fallbackAccountId ?? "default").trim() || "default";
+    const account = resolveDdchatAccount(params.cfg, accountId);
+    if (!account.enabled) {
+        throw new Error(`ddchat account '${account.accountId}' is disabled`);
+    }
+    const identity = resolveInboundIdentity(body);
+    if (getDdchatState().dedupe.isDuplicate(account.accountId, identity.messageId)) {
+        return {
+            ok: true,
+            duplicate: true,
+            messageId: identity.messageId,
+            accountId: account.accountId,
+        };
+    }
+    const peer = identity.chatType === "group"
+        ? { kind: "group", id: identity.groupId }
+        : { kind: "direct", id: identity.userId };
+    const route = params.channelRuntime.routing.resolveAgentRoute({
+        cfg: params.cfg,
+        channel: DDCHAT_CHANNEL_ID,
+        accountId: account.accountId,
+        peer,
+    });
+    const mediaList = await resolveInboundMedia({
+        channelRuntime: params.channelRuntime,
+        cfg: params.cfg,
+        files: toInboundFiles(body),
+        logInfo: params.logInfo,
+    });
+    const mediaPayload = buildLocalAgentMediaPayload(mediaList);
+    const inboundText = typeof body.text === "string" && body.text.trim()
+        ? body.text.trim()
+        : mediaList.length > 0
+            ? inferBodyFromMedia(mediaList)
+            : "";
+    if (!inboundText) {
+        throw new Error("missing text/files");
+    }
+    const timestamp = Date.now();
+    const from = `ddchat:${identity.userId}`;
+    const to = identity.chatType === "group" ? `group:${identity.groupId}` : `user:${identity.userId}`;
+    const ctxPayload = params.channelRuntime.reply.finalizeInboundContext({
+        Body: inboundText,
+        BodyForAgent: inboundText,
+        RawBody: inboundText,
+        CommandBody: inboundText,
+        From: from,
+        To: to,
+        SessionKey: route.sessionKey,
+        AccountId: route.accountId,
+        ChatType: identity.chatType,
+        GroupSubject: identity.chatType === "group" ? identity.groupId : undefined,
+        SenderId: identity.userId,
+        MessageSid: identity.messageId,
+        Timestamp: timestamp,
+        Provider: DDCHAT_CHANNEL_ID,
+        Surface: DDCHAT_CHANNEL_ID,
+        OriginatingChannel: DDCHAT_CHANNEL_ID,
+        OriginatingTo: to,
+        CommandAuthorized: true,
+        ...mediaPayload,
+    });
+    const delivered = [];
+    const streamId = `ddchat-stream-${identity.messageId}`;
+    let streamText = "";
+    const streamMode = account.streamingMode;
+    const emitStream = (patch) => {
+        const runtime = getDdchatWsRuntime(account.accountId);
+        const sent = runtime.send?.({
+            type: "stream_chunk",
+            streamId,
+            accountId: account.accountId,
+            source: params.source ?? "ws",
+            sessionKey: route.sessionKey,
+            agentId: route.agentId,
+            mode: streamMode,
+            delta: patch.delta ?? "",
+            fullText: streamText,
+            done: patch.done,
+            from: "claw",
+            ts: Date.now(),
+        }) ?? false;
+        if (!sent) {
+            params.logInfo?.(`ddchat stream send failed for account ${account.accountId}`);
+        }
+    };
+    await params.channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg: params.cfg,
+        dispatcherOptions: {
+            deliver: async (payload) => {
+                const text = payload.text ?? payload.body ?? "";
+                const mediaUrl = payload.mediaUrl?.trim() || payload.mediaUrls?.find((u) => u?.trim())?.trim();
+                if (!text && !mediaUrl) {
+                    return;
+                }
+                const mediaFields = mediaUrl
+                    ? await resolveDdchatOutboundMediaFields(params.cfg, mediaUrl)
+                    : {};
+                const outbound = {
+                    type: "outbound_message",
+                    from: "claw",
+                    channel: DDCHAT_CHANNEL_ID,
+                    accountId: account.accountId,
+                    targetType: identity.chatType,
+                    targetId: identity.chatType === "group" ? identity.groupId : identity.userId,
+                    text,
+                    mediaUrl,
+                    ...mediaFields,
+                };
+                if (!account.streaming || !text) {
+                    const runtime = getDdchatWsRuntime(account.accountId);
+                    const sent = runtime.send?.(outbound) ?? false;
+                    if (!sent) {
+                        params.logInfo?.(`ddchat outbound send failed for account ${account.accountId}`);
+                    }
+                }
+                delivered.push({
+                    messageId: createDdchatMessageId("ddchat-out"),
+                    text,
+                });
+                if (account.streaming && text) {
+                    streamText += text;
+                    emitStream({ delta: text, done: false });
+                }
+            },
+            onReplyStart: () => {
+                params.logInfo?.("ddchat agent reply started");
+            },
+        },
+    });
+    if (account.streaming) {
+        emitStream({ done: true });
+    }
+    return {
+        ok: true,
+        sessionKey: route.sessionKey,
+        agentId: route.agentId,
+        deliveredCount: delivered.length,
+        delivered,
+    };
+}

package/src/outbound.js

@@ -0,0 +1,150 @@
+import { randomUUID } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
+import { DDCHAT_CHANNEL_ID } from "./constants.js";
+import { getDdchatWsRuntime } from "./runtime.js";
+import { resolveDdchatMediaMaxBytes } from "./types.js";
+function createDdchatMessageId(prefix) {
+    return `${prefix}-${randomUUID()}`;
+}
+function isLocalFilePath(url) {
+    if (url.startsWith("file://"))
+        return true;
+    if (/^[a-zA-Z]:[\\/]/.test(url))
+        return true;
+    if (url.startsWith("/") && !url.startsWith("//"))
+        return true;
+    return false;
+}
+function toFileUrl(path) {
+    if (path.startsWith("file://"))
+        return path;
+    return pathToFileURL(path).href;
+}
+export async function resolveDdchatOutboundMediaFields(cfg, mediaUrl) {
+    try {
+        let resolvedUrl = mediaUrl;
+        if (isLocalFilePath(mediaUrl)) {
+            resolvedUrl = toFileUrl(mediaUrl);
+        }
+        console.log(`[ddchat] Resolved media URL: ${resolvedUrl}`);
+        const media = await loadWebMedia(resolvedUrl, {
+            maxBytes: resolveDdchatMediaMaxBytes(cfg),
+        });
+        console.log(`[ddchat] Media loaded successfully: ${media.fileName}, type: ${media.contentType}, size: ${media.buffer.length}`);
+        return {
+            mediaBase64: media.buffer.toString("base64"),
+            mediaType: media.contentType,
+            mediaName: media.fileName,
+        };
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`[ddchat] Failed to load media from ${mediaUrl}: ${errorMsg}`);
+        return { error: errorMsg };
+    }
+}
+function resolveTarget(to) {
+    const normalized = to.trim();
+    if (normalized.startsWith("group:")) {
+        return { targetType: "group", targetId: normalized.slice("group:".length) };
+    }
+    if (normalized.startsWith("chat:")) {
+        return { targetType: "group", targetId: normalized.slice("chat:".length) };
+    }
+    if (normalized.startsWith("user:")) {
+        return { targetType: "direct", targetId: normalized.slice("user:".length) };
+    }
+    return { targetType: "direct", targetId: normalized };
+}
+export const ddchatOutbound = {
+    deliveryMode: "direct",
+    textChunkLimit: 4000,
+    chunkerMode: "markdown",
+    sendText: async ({ to, text, accountId = "default" }) => {
+        const messageId = createDdchatMessageId("ddchat-text");
+        const target = resolveTarget(to);
+        const runtime = getDdchatWsRuntime(accountId);
+        if (!runtime.send || !runtime.connected) {
+            throw new Error("DDChat WebSocket not connected");
+        }
+        const payload = {
+            type: "outbound_message",
+            from: "claw",
+            channel: DDCHAT_CHANNEL_ID,
+            accountId,
+            messageId,
+            targetType: target.targetType,
+            targetId: target.targetId,
+            text,
+        };
+        console.log(`[ddchat] Sending text payload:`, JSON.stringify(payload, null, 2));
+        const sent = runtime.send(payload);
+        if (!sent) {
+            throw new Error("Failed to send text message via WebSocket");
+        }
+        return {
+            messageId,
+            to,
+            channel: DDCHAT_CHANNEL_ID,
+            text,
+            transport: "ws",
+        };
+    },
+    sendMedia: async ({ cfg, to, text, mediaUrl, accountId = "default" }) => {
+        const messageId = createDdchatMessageId("ddchat-media");
+        const target = resolveTarget(to);
+        const runtime = getDdchatWsRuntime(accountId);
+        console.log(`[ddchat] sendMedia called - wsConnected: ${runtime.connected}, wsSend available: ${!!runtime.send}`);
+        if (!runtime.send || !runtime.connected) {
+            throw new Error("DDChat WebSocket not connected");
+        }
+        console.log(`[ddchat] Loading media from: ${mediaUrl}`);
+        const { mediaBase64, mediaType, mediaName, error } = await resolveDdchatOutboundMediaFields(cfg, mediaUrl);
+        if (error) {
+            console.error(`[ddchat] Media loading failed: ${error}`);
+            throw new Error(`Failed to load media: ${error}`);
+        }
+        if (!mediaBase64) {
+            console.error(`[ddchat] No media data available for ${mediaUrl}`);
+            throw new Error("No media data available");
+        }
+        const payload = {
+            type: "outbound_message",
+            from: "claw",
+            channel: DDCHAT_CHANNEL_ID,
+            accountId,
+            messageId,
+            targetType: target.targetType,
+            targetId: target.targetId,
+            text,
+            mediaUrl,
+            mediaBase64,
+            mediaType,
+            mediaName,
+        };
+        console.log(`[ddchat] Sending media message:`, {
+            messageId,
+            targetType: target.targetType,
+            targetId: target.targetId,
+            mediaType,
+            mediaName,
+            mediaSize: mediaBase64?.length,
+        });
+        const sent = runtime.send(payload);
+        if (!sent) {
+            console.error(`[ddchat] Failed to send media message via WebSocket`);
+            throw new Error("Failed to send media message via WebSocket");
+        }
+        return {
+            messageId,
+            to,
+            channel: DDCHAT_CHANNEL_ID,
+            text,
+            mediaUrl,
+            mediaType,
+            mediaName,
+            transport: "ws",
+        };
+    },
+};

package/src/pairing.js

@@ -0,0 +1,8 @@
+import { createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
+export const ddchatPairing = {
+    idLabel: "ddchatUserId",
+    normalizeAllowEntry: createPairingPrefixStripper(/^(ddchat|user):/i),
+    notifyApproval: async ({ runtime, id }) => {
+        runtime?.log?.(`[ddchat] pairing approved for ${id}`);
+    },
+};

package/src/runtime.js

@@ -0,0 +1,20 @@
+import { DdchatDedupeStore } from "./dedupe.js";
+const state = {
+    dedupe: new DdchatDedupeStore(),
+    wsByAccount: new Map(),
+};
+export function getDdchatState() {
+    return state;
+}
+export function getDdchatWsRuntime(accountId) {
+    return state.wsByAccount.get(accountId) ?? { connected: false };
+}
+export function setDdchatWsRuntime(params) {
+    state.wsByAccount.set(params.accountId, {
+        send: params.send,
+        connected: params.connected,
+    });
+}
+export function clearDdchatWsRuntime(accountId) {
+    state.wsByAccount.delete(accountId);
+}

package/src/session.js

@@ -0,0 +1,13 @@
+export function buildDdchatSessionKey(params) {
+    const base = params.peerKind === "group"
+        ? `ddchat:group:${params.peerId}`
+        : `ddchat:direct:${params.peerId}`;
+    const thread = params.threadId?.trim();
+    if (!thread) {
+        return base;
+    }
+    if (params.peerKind === "group" && params.senderId) {
+        return `${base}:thread:${thread}:sender:${params.senderId}`;
+    }
+    return `${base}:thread:${thread}`;
+}

package/src/types.js

@@ -0,0 +1,73 @@
+import { DDCHAT_CHANNEL_ID, DDCHAT_DEFAULT_ACCOUNT_ID } from "./constants.js";
+export function resolveDdchatMediaMaxBytes(cfg) {
+    const mb = cfg.agents?.defaults?.mediaMaxMb;
+    if (!mb || mb <= 0) {
+        return undefined;
+    }
+    return mb * 1024 * 1024;
+}
+function toStringList(input) {
+    if (!input) {
+        return [];
+    }
+    return input.map((entry) => String(entry).trim()).filter(Boolean);
+}
+function normalizeWebhookPath(path) {
+    const trimmed = path?.trim();
+    return trimmed?.startsWith("/") ? trimmed : "/ddchat/webhook";
+}
+function normalizeConnectionMode(mode) {
+    return mode === "webhook" ? "webhook" : "websocket";
+}
+function normalizeStreamingMode(mode) {
+    return mode === "token" ? "token" : "chunk";
+}
+function readChannelConfig(cfg) {
+    return (cfg.channels?.[DDCHAT_CHANNEL_ID] ?? {});
+}
+function mergeAccountConfig(params) {
+    const { root, account } = params;
+    return {
+        ...root,
+        ...account,
+    };
+}
+export function listDdchatAccountIds(cfg) {
+    const channelCfg = readChannelConfig(cfg);
+    const keys = Object.keys(channelCfg.accounts ?? {}).filter((key) => key.trim().length > 0);
+    return keys.length > 0 ? keys : [DDCHAT_DEFAULT_ACCOUNT_ID];
+}
+export function resolveDefaultDdchatAccountId(cfg) {
+    const channelCfg = readChannelConfig(cfg);
+    const ids = listDdchatAccountIds(cfg);
+    const configured = channelCfg.defaultAccount?.trim();
+    return configured && ids.includes(configured) ? configured : ids[0];
+}
+export function resolveDdchatAccount(cfg, accountId) {
+    const channelCfg = readChannelConfig(cfg);
+    const resolvedAccountId = accountId?.trim() || resolveDefaultDdchatAccountId(cfg);
+    const named = channelCfg.accounts?.[resolvedAccountId];
+    const merged = mergeAccountConfig({ root: channelCfg, account: named });
+    const token = typeof merged.token === "string" ? merged.token.trim() : "";
+    const wsUrl = typeof merged.wsUrl === "string" ? merged.wsUrl.trim() : "";
+    return {
+        accountId: resolvedAccountId,
+        enabled: merged.enabled !== false,
+        configured: Boolean(token),
+        token: token || undefined,
+        wsUrl: wsUrl || undefined,
+        webhookPath: normalizeWebhookPath(merged.webhookPath),
+        webhookPort: typeof merged.webhookPort === "number" && Number.isFinite(merged.webhookPort)
+            ? merged.webhookPort
+            : 3010,
+        connectionMode: normalizeConnectionMode(merged.connectionMode),
+        dmPolicy: merged.dmPolicy ?? "pairing",
+        groupPolicy: merged.groupPolicy ?? "allowlist",
+        requireMention: merged.requireMention === true,
+        streaming: merged.streaming !== false,
+        streamingMode: normalizeStreamingMode(merged.streamingMode),
+        allowFrom: toStringList(merged.allowFrom),
+        groupAllowFrom: toStringList(merged.groupAllowFrom),
+        heartbeatSec: Math.max(15, Number(merged.heartbeatSec ?? 60) || 60),
+    };
+}

package/CLAUDE.md

@@ -1,51 +0,0 @@
-# CLAUDE.md
-
-本文件为 Claude Code (claude.ai/code) 在本仓库中工作时提供指导。
-
-## 项目概述
-
-DDChat 频道插件 (`@ddchat/openclaw-ddchat`) — OpenClaw AI 智能体平台的 DDChat（内部即时通讯）频道集成插件。通过 WebSocket 或 Webhook 连接，将 DDChat 的私聊和群聊消息桥接到 OpenClaw 智能体。
-
-## 技术栈
-
-- TypeScript，ES 模块 (`"type": "module"`)
-- OpenClaw monorepo 的一部分（使用 `workspace:*` 依赖）
-- OpenClaw 插件 SDK：`openclaw/plugin-sdk/core`、`openclaw/plugin-sdk/setup`、`openclaw/plugin-sdk/channel-pairing`、`openclaw/plugin-sdk/media-runtime`
-
-## 开发与测试
-
-```bash
-# 启动模拟 DDChat 服务器（WebSocket 端口 :9001，HTTP 界面端口 :9020）
-node ddchat/test/server.mjs
-
-# 将插件安装到 OpenClaw
-openclaw channels add --channel ddchat --token "appId:appSecret"
-```
-
-无独立的构建或测试脚本 — 构建由 OpenClaw 工作区统一处理。
-
-## 架构
-
-插件遵循 OpenClaw 的 `ChatChannelPlugin` 模式，包含以下核心模块：
-
-- **`index.ts`** — 插件入口，导出 extensions 和 setup entry
-- **`src/channel.ts`** — 插件定义：能力声明、配置 schema、安装流程、网关、安全策略
-- **`src/gateway.ts`** — WebSocket 生命周期：连接、认证（token 作为查询参数）、心跳 ping/pong、指数退避重连（1s→2s→5s→10s→30s）
-- **`src/inbound.ts`** — 接收消息（WebSocket 或 webhook），去重，解析媒体/文件，路由到 AI 智能体，处理流式响应
-- **`src/outbound.ts`** — 将智能体回复发送回 DDChat；按 4000 字符使用 markdown 感知方式分块；处理媒体附件（base64 或 URL）
-- **`src/types.ts`** — `DdchatResolvedAccount` 配置类型、账户解析/合并逻辑、策略类型
-- **`src/runtime.ts`** — 全局插件状态：去重存储、WebSocket 发送函数
-- **`src/dedupe.ts`** — 基于 TTL 的消息去重（默认 48 小时），带 GC 回收
-- **`src/pairing.ts`** — 用户配对审批流程，ID 标准化（去除前缀）
-- **`src/session.ts`** — 会话 key 构造，用于私聊/群聊路由
-
-**数据流：** DDChat → WebSocket/Webhook → inbound.ts（去重、解析、媒体处理）→ OpenClaw 智能体 → outbound.ts（分块、发送）→ DDChat
-
-## 关键约定
-
-- 出站消息包含 `from: "plugin"` 字段
-- 标识符：From 使用 `ddchat:${userId}`，To 使用 `user:${userId}` / `group:${groupId}`
-- 流式 ID：`ddchat-stream-${messageId}`
-- 连接模式：`websocket`（默认）| `webhook`
-- 访问策略：私聊使用 `open | pairing | allowlist`（默认：pairing）；群聊使用 `open | allowlist | disabled`（默认：allowlist）
-- 流式模式：`chunk` | `token`