ddchat 0.3.0 → 0.4.1

package/{index.ts → index.js}

@@ -1,13 +1,11 @@
 import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
 import { ddchatPlugin } from "./src/channel.js";
 import { registerDdchatWebhook } from "./src/inbound.js";
-
 export { ddchatPlugin } from "./src/channel.js";
-
 export default defineChannelPluginEntry({
-  id: "ddchat",
-  name: "DDChat",
-  description: "DDChat channel plugin",
-  plugin: ddchatPlugin,
-  registerFull: registerDdchatWebhook,
+    id: "ddchat",
+    name: "DDChat",
+    description: "DDChat channel plugin",
+    plugin: ddchatPlugin,
+    registerFull: registerDdchatWebhook,
 });

package/openclaw.plugin.json

@@ -5,10 +5,144 @@
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
-    "properties": {
-      "channels": {
+    "properties": {}
+  },
+  "channelConfigs": {
+    "ddchat": {
+      "label": "DDChat",
+      "description": "DDChat internal IM integration.",
+      "schema": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
         "type": "object",
-        "additionalProperties": true
+        "additionalProperties": false,
+        "properties": {
+          "name": { "type": "string" },
+          "enabled": { "type": "boolean" },
+          "token": { "type": "string" },
+          "wsUrl": { "type": "string" },
+          "webhookPath": { "type": "string" },
+          "webhookPort": {
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 9007199254740991
+          },
+          "connectionMode": {
+            "type": "string",
+            "enum": ["websocket", "webhook"]
+          },
+          "dmPolicy": {
+            "type": "string",
+            "enum": ["open", "pairing", "allowlist"]
+          },
+          "groupPolicy": {
+            "type": "string",
+            "enum": ["open", "allowlist", "disabled"]
+          },
+          "requireMention": { "type": "boolean" },
+          "streaming": { "type": "boolean" },
+          "streamingMode": {
+            "type": "string",
+            "enum": ["chunk", "token"]
+          },
+          "allowFrom": {
+            "type": "array",
+            "items": {
+              "anyOf": [{ "type": "string" }, { "type": "number" }]
+            }
+          },
+          "groupAllowFrom": {
+            "type": "array",
+            "items": {
+              "anyOf": [{ "type": "string" }, { "type": "number" }]
+            }
+          },
+          "heartbeatSec": {
+            "type": "number",
+            "minimum": 15
+          },
+          "defaultAccount": { "type": "string" },
+          "accounts": {
+            "type": "object",
+            "propertyNames": { "type": "string" },
+            "additionalProperties": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "name": { "type": "string" },
+                "enabled": { "type": "boolean" },
+                "token": { "type": "string" },
+                "wsUrl": { "type": "string" },
+                "webhookPath": { "type": "string" },
+                "webhookPort": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "maximum": 9007199254740991
+                },
+                "connectionMode": {
+                  "type": "string",
+                  "enum": ["websocket", "webhook"]
+                },
+                "dmPolicy": {
+                  "type": "string",
+                  "enum": ["open", "pairing", "allowlist"]
+                },
+                "groupPolicy": {
+                  "type": "string",
+                  "enum": ["open", "allowlist", "disabled"]
+                },
+                "requireMention": { "type": "boolean" },
+                "streaming": { "type": "boolean" },
+                "streamingMode": {
+                  "type": "string",
+                  "enum": ["chunk", "token"]
+                },
+                "allowFrom": {
+                  "type": "array",
+                  "items": {
+                    "anyOf": [{ "type": "string" }, { "type": "number" }]
+                  }
+                },
+                "groupAllowFrom": {
+                  "type": "array",
+                  "items": {
+                    "anyOf": [{ "type": "string" }, { "type": "number" }]
+                  }
+                },
+                "heartbeatSec": {
+                  "type": "number",
+                  "minimum": 15
+                }
+              }
+            }
+          }
+        }
+      },
+      "uiHints": {
+        "": {
+          "label": "DDChat",
+          "help": "DDChat channel provider configuration for WebSocket/Webhook transport, account credentials, and access policies."
+        },
+        "token": {
+          "label": "DDChat Token",
+          "sensitive": true
+        },
+        "accounts.*.token": {
+          "label": "DDChat Token",
+          "sensitive": true
+        },
+        "connectionMode": {
+          "label": "DDChat Connection Mode"
+        },
+        "dmPolicy": {
+          "label": "DDChat DM Policy"
+        },
+        "groupPolicy": {
+          "label": "DDChat Group Policy"
+        }
+      },
+      "commands": {
+        "nativeCommandsAutoEnabled": false,
+        "nativeSkillsAutoEnabled": false
       }
     }
   }

package/package.json

@@ -1,11 +1,9 @@
 {
   "name": "ddchat",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "DDChat channel plugin for OpenClaw",
   "type": "module",
-  "devDependencies": {
-    "openclaw": "^2026.2.0"
-  },
+  "main": "./index.js",
   "peerDependencies": {
     "openclaw": ">=2026.2.0"
   },
@@ -16,14 +14,16 @@
   },
   "openclaw": {
     "extensions": [
-      "./index.ts"
+      "./index.js"
     ],
-    "setupEntry": "./setup-entry.ts",
+    "setupEntry": "./setup-entry.js",
     "channel": {
       "id": "ddchat",
       "label": "DDChat",
       "selectionLabel": "DDChat (IM)",
       "detailLabel": "DDChat IM",
+      "docsPath": "/channels/ddchat",
+      "docsLabel": "ddchat",
       "blurb": "DDChat internal IM integration.",
       "order": 90
     },

package/setup-entry.js

@@ -0,0 +1,8 @@
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
+import { ddchatPlugin } from "./src/channel.js";
+export default defineChannelPluginEntry({
+    id: "ddchat",
+    name: "DDChat",
+    description: "DDChat channel setup plugin",
+    plugin: ddchatPlugin,
+});

package/src/channel.js

@@ -0,0 +1,99 @@
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
+import { patchScopedAccountConfig, prepareScopedSetupConfig } from "openclaw/plugin-sdk/setup";
+import { DDCHAT_CHANNEL_ID } from "./constants.js";
+import { ddchatGateway } from "./gateway.js";
+import { ddchatOutbound } from "./outbound.js";
+import { ddchatPairing } from "./pairing.js";
+import { listDdchatAccountIds, resolveDdchatAccount } from "./types.js";
+function inspectDdchatAccount(cfg, accountId) {
+    const account = resolveDdchatAccount(cfg, accountId);
+    return {
+        enabled: account.enabled,
+        configured: account.configured,
+        tokenStatus: account.token ? "available" : "missing",
+        connectionMode: account.connectionMode,
+        dmPolicy: account.dmPolicy,
+        groupPolicy: account.groupPolicy,
+        streaming: account.streaming,
+        streamingMode: account.streamingMode,
+    };
+}
+export const ddchatPlugin = createChatChannelPlugin({
+    base: {
+        id: DDCHAT_CHANNEL_ID,
+        meta: {
+            id: DDCHAT_CHANNEL_ID,
+            label: "DDChat",
+            selectionLabel: "DDChat (IM)",
+            docsPath: "/channels/ddchat",
+            blurb: "DDChat internal IM integration.",
+            order: 90,
+        },
+        capabilities: {
+            chatTypes: ["direct", "channel"],
+            media: true,
+            threads: false,
+            polls: false,
+        },
+        config: {
+            listAccountIds: (cfg) => listDdchatAccountIds(cfg),
+            resolveAccount: (cfg, accountId) => resolveDdchatAccount(cfg, accountId),
+            inspectAccount: inspectDdchatAccount,
+            isEnabled: (account) => account.enabled,
+            isConfigured: (account) => account.configured,
+        },
+        setup: {
+            resolveAccountId: ({ accountId }) => accountId ?? "default",
+            applyAccountName: ({ cfg, accountId, name }) => prepareScopedSetupConfig({
+                cfg,
+                channelKey: DDCHAT_CHANNEL_ID,
+                accountId,
+                name,
+                alwaysUseAccounts: true,
+            }),
+            validateInput: ({ input }) => {
+                const token = typeof input.token === "string" ? input.token.trim() : "";
+                return token ? null : "ddchat requires --token";
+            },
+            applyAccountConfig: ({ cfg, accountId, input }) => {
+                const token = typeof input.token === "string" ? input.token.trim() : "";
+                const next = prepareScopedSetupConfig({
+                    cfg,
+                    channelKey: DDCHAT_CHANNEL_ID,
+                    accountId,
+                    name: input.name,
+                    alwaysUseAccounts: true,
+                });
+                const patch = {};
+                if (token) {
+                    patch.token = token;
+                }
+                return patchScopedAccountConfig({
+                    cfg: next,
+                    channelKey: DDCHAT_CHANNEL_ID,
+                    accountId,
+                    patch,
+                    accountPatch: patch,
+                    ensureChannelEnabled: true,
+                    ensureAccountEnabled: true,
+                    scopeDefaultToAccounts: true,
+                });
+            },
+        },
+        gateway: ddchatGateway,
+    },
+    pairing: ddchatPairing,
+    security: {
+        dm: {
+            channelKey: DDCHAT_CHANNEL_ID,
+            resolvePolicy: (account) => account.dmPolicy,
+            resolveAllowFrom: (account) => account.allowFrom,
+            defaultPolicy: "pairing",
+            normalizeEntry: (raw) => raw.replace(/^ddchat:/i, "").trim(),
+        },
+    },
+    outbound: ddchatOutbound,
+    threading: {
+        topLevelReplyToMode: "off",
+    },
+});

package/src/{constants.ts → constants.js}

@@ -1,5 +1,4 @@
 export const DDCHAT_CHANNEL_ID = "ddchat";
 export const DDCHAT_DEFAULT_ACCOUNT_ID = "default";
-
 /** Default WebSocket endpoint when `channels.ddchat.wsUrl` / per-account `wsUrl` is unset (`token` query appended at connect). */
 export const DDCHAT_PLUGIN_WS_BASE_URL = "wss://chat.ddjf.info/socket/ai/claw";

package/src/dedupe.js

@@ -0,0 +1,44 @@
+const DEFAULT_TTL_MS = 48 * 60 * 60 * 1000;
+const DEFAULT_GC_INTERVAL_MS = 60 * 1000;
+const DEFAULT_GC_CHECK_INTERVAL = 1000;
+export class DdchatDedupeStore {
+    gcIntervalMs;
+    gcCheckInterval;
+    seen = new Map();
+    ttlMs;
+    lastGcAt = 0;
+    checksSinceGc = 0;
+    constructor(ttlMs = DEFAULT_TTL_MS, gcIntervalMs = DEFAULT_GC_INTERVAL_MS, gcCheckInterval = DEFAULT_GC_CHECK_INTERVAL) {
+        this.gcIntervalMs = gcIntervalMs;
+        this.gcCheckInterval = gcCheckInterval;
+        this.ttlMs = ttlMs;
+    }
+    isDuplicate(accountId, messageId) {
+        const key = `${accountId}:${messageId}`;
+        const now = Date.now();
+        this.gcIfNeeded(now);
+        const expiresAt = this.seen.get(key);
+        if (expiresAt && expiresAt > now) {
+            return true;
+        }
+        this.seen.set(key, now + this.ttlMs);
+        return false;
+    }
+    gcIfNeeded(now) {
+        this.checksSinceGc += 1;
+        if (now - this.lastGcAt < this.gcIntervalMs &&
+            this.checksSinceGc < this.gcCheckInterval) {
+            return;
+        }
+        this.lastGcAt = now;
+        this.checksSinceGc = 0;
+        this.gc(now);
+    }
+    gc(now) {
+        for (const [key, expiresAt] of this.seen.entries()) {
+            if (expiresAt <= now) {
+                this.seen.delete(key);
+            }
+        }
+    }
+}

package/src/gateway.js

@@ -0,0 +1,211 @@
+import { DDCHAT_PLUGIN_WS_BASE_URL } from "./constants.js";
+import { processDdchatInboundWithChannelRuntime } from "./inbound.js";
+import { clearDdchatWsRuntime, setDdchatWsRuntime } from "./runtime.js";
+function createReconnectDelayMs(attempt) {
+    const base = [1000, 2000, 5000, 10000, 30000][Math.min(attempt, 4)] ?? 30000;
+    const jitter = Math.floor(Math.random() * 300);
+    return base + jitter;
+}
+export const ddchatGateway = {
+    startAccount: async (ctx) => {
+        ctx.log?.info?.(`[ddchat:${ctx.accountId}] start mode=${ctx.account.connectionMode} heartbeat=${ctx.account.heartbeatSec}s stream=${ctx.account.streamingMode}`);
+        if (ctx.account.connectionMode === "webhook") {
+            clearDdchatWsRuntime(ctx.accountId);
+            ctx.setStatus({
+                accountId: ctx.accountId,
+                running: true,
+                connected: true,
+                reconnectAttempts: 0,
+                heartbeatSec: ctx.account.heartbeatSec,
+                inboundMode: "webhook",
+            });
+            await new Promise((resolve) => {
+                if (ctx.abortSignal.aborted) {
+                    resolve();
+                    return;
+                }
+                ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+            });
+            return;
+        }
+        const wsUrl = ctx.account.wsUrl?.trim() || DDCHAT_PLUGIN_WS_BASE_URL;
+        const token = ctx.account.token?.trim();
+        if (!token) {
+            throw new Error(`ddchat[${ctx.accountId}] missing token (set via channels add --token or config)`);
+        }
+        const resolvedWsUrl = appendDdchatAuthQuery(wsUrl, token);
+        let attempts = 0;
+        while (!ctx.abortSignal.aborted) {
+            attempts += 1;
+            const reconnectDelay = createReconnectDelayMs(attempts);
+            try {
+                await runWsSession({ ctx, wsUrl: resolvedWsUrl, wsUrlForLog: redactDdchatWsUrl(resolvedWsUrl), attempts });
+                if (ctx.abortSignal.aborted) {
+                    break;
+                }
+            }
+            catch (error) {
+                ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws session failed: ${String(error)}`);
+            }
+            if (ctx.abortSignal.aborted) {
+                break;
+            }
+            ctx.log?.warn?.(`[ddchat:${ctx.accountId}] reconnecting in ${reconnectDelay}ms`);
+            await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
+        }
+    },
+    stopAccount: async (ctx) => {
+        clearDdchatWsRuntime(ctx.accountId);
+        ctx.setStatus({
+            accountId: ctx.accountId,
+            running: false,
+            connected: false,
+        });
+        ctx.log?.info?.(`[ddchat:${ctx.accountId}] stopped`);
+    },
+};
+function appendDdchatAuthQuery(wsUrl, token) {
+    try {
+        const url = new URL(wsUrl);
+        url.searchParams.set("token", token);
+        return url.toString();
+    }
+    catch {
+        const hasQuery = wsUrl.includes("?");
+        const sep = hasQuery ? "&" : "?";
+        return `${wsUrl}${sep}token=${encodeURIComponent(token)}`;
+    }
+}
+function redactDdchatWsUrl(wsUrl) {
+    try {
+        const url = new URL(wsUrl);
+        if (url.searchParams.has("token")) {
+            url.searchParams.set("token", "(redacted)");
+        }
+        return url.toString();
+    }
+    catch {
+        return wsUrl.replace(/([?&]token=)[^&]*/i, "$1(redacted)");
+    }
+}
+async function runWsSession(params) {
+    const { ctx, wsUrl, wsUrlForLog, attempts } = params;
+    await new Promise((resolve, reject) => {
+        const WebSocketCtor = globalThis.WebSocket;
+        if (!WebSocketCtor) {
+            reject(new Error("WebSocket is not available in this runtime"));
+            return;
+        }
+        const ws = new WebSocketCtor(wsUrl);
+        let heartbeatTimer;
+        let settled = false;
+        const finish = (fn) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (heartbeatTimer) {
+                clearInterval(heartbeatTimer);
+            }
+            clearDdchatWsRuntime(ctx.accountId);
+            fn();
+        };
+        ws.addEventListener("open", () => {
+            ctx.log?.info?.(`[ddchat:${ctx.accountId}] ws connected -> ${wsUrlForLog}`);
+            setDdchatWsRuntime({
+                accountId: ctx.accountId,
+                connected: true,
+                send: (payload) => {
+                    if (ws.readyState !== WebSocket.OPEN) {
+                        return false;
+                    }
+                    ws.send(JSON.stringify(payload));
+                    return true;
+                },
+            });
+            ctx.setStatus({
+                accountId: ctx.accountId,
+                running: true,
+                connected: true,
+                reconnectAttempts: attempts - 1,
+                heartbeatSec: ctx.account.heartbeatSec,
+                inboundMode: "ws",
+                wsUrl: wsUrlForLog,
+            });
+            heartbeatTimer = setInterval(() => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({ type: "ping", ts: Date.now(), from: "claw" }));
+                }
+            }, Math.max(1000, ctx.account.heartbeatSec * 1000));
+        });
+        ws.addEventListener("message", async (event) => {
+            let ackContext = { accountId: ctx.accountId };
+            try {
+                const raw = typeof event.data === "string" ? event.data : String(event.data);
+                const message = JSON.parse(raw);
+                ackContext = {
+                    accountId: String(message.accountId ?? ctx.accountId).trim() || ctx.accountId,
+                    messageId: typeof message.messageId === "string" ? message.messageId : undefined,
+                };
+                if (message.type === "ping") {
+                    ws.send(JSON.stringify({ type: "pong", ts: Date.now(), from: "claw" }));
+                    return;
+                }
+                if (message.type !== "inbound_message") {
+                    return;
+                }
+                if (!ctx.channelRuntime) {
+                    throw new Error("channelRuntime unavailable in gateway context");
+                }
+                const result = await processDdchatInboundWithChannelRuntime({
+                    channelRuntime: ctx.channelRuntime,
+                    cfg: ctx.cfg,
+                    body: message,
+                    fallbackAccountId: ctx.accountId,
+                    source: "ws",
+                    logInfo: (msg) => ctx.log?.info?.(msg),
+                });
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({ type: "ack", ok: true, from: "claw", result }));
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws message handling failed: ${errorMessage}`);
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({
+                        type: "ack",
+                        ok: false,
+                        from: "claw",
+                        accountId: ackContext.accountId,
+                        messageId: ackContext.messageId,
+                        error: errorMessage,
+                    }));
+                }
+            }
+        });
+        ws.addEventListener("error", (event) => {
+            ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws error: ${String(event.type)}`);
+        });
+        ws.addEventListener("close", () => {
+            finish(resolve);
+        });
+        if (ctx.abortSignal.aborted) {
+            try {
+                ws.close();
+            }
+            catch { }
+            finish(resolve);
+            return;
+        }
+        ctx.abortSignal.addEventListener("abort", () => {
+            try {
+                ws.close();
+            }
+            catch (error) {
+                reject(error);
+            }
+            finish(resolve);
+        }, { once: true });
+    });
+}