ddchat 0.1.0

package/README.md

@@ -0,0 +1,14 @@
+# 本地安装ddchat插件
+```shell
+openclaw plugins install "安装包路径"
+```
+
+# 默认default账号
+```shell
+openclaw channels add --channel ddchat --token "appId:appSecret"
+```
+
+# 多个账号时指定账户名 避免覆盖
+```shell
+openclaw channels add --channel ddchat --account xxx --token "appId:appSecret"
+```

package/index.ts

@@ -0,0 +1,13 @@
+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,
+});

package/openclaw.plugin.json

@@ -0,0 +1,15 @@
+{
+  "id": "ddchat",
+  "kind": "channel",
+  "channels": ["ddchat"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "channels": {
+        "type": "object",
+        "additionalProperties": true
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "ddchat",
+  "version": "0.1.0",
+  "description": "DDChat channel plugin for OpenClaw",
+  "type": "module",
+  "devDependencies": {
+    "openclaw": "workspace:*"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.2.0"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "setupEntry": "./setup-entry.ts",
+    "channel": {
+      "id": "ddchat",
+      "label": "DDChat",
+      "selectionLabel": "DDChat (IM)",
+      "detailLabel": "DDChat IM",
+      "blurb": "DDChat internal IM integration.",
+      "order": 90
+    },
+    "install": {
+      "npmSpec": "ddchat",
+      "localPath": "ddchat",
+      "defaultChoice": "local"
+    }
+  }
+}

package/setup-entry.ts

@@ -0,0 +1,4 @@
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/core";
+import { ddchatPlugin } from "./src/channel.js";
+
+export default defineSetupPluginEntry(ddchatPlugin);

package/src/channel.ts

@@ -0,0 +1,101 @@
+import { createChatChannelPlugin, type OpenClawConfig } 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, type DdchatResolvedAccount } from "./types.js";
+
+function inspectDdchatAccount(cfg: OpenClawConfig, accountId?: string | null) {
+  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<DdchatResolvedAccount>({
+  base: {
+    id: DDCHAT_CHANNEL_ID,
+    meta: {
+      id: DDCHAT_CHANNEL_ID,
+      label: "DDChat",
+      selectionLabel: "DDChat (IM)",
+      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: Record<string, unknown> = {};
+        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

@@ -0,0 +1,5 @@
+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/plugin";

package/src/dedupe.ts

@@ -0,0 +1,31 @@
+const DEFAULT_TTL_MS = 48 * 60 * 60 * 1000;
+
+export class DdchatDedupeStore {
+  private readonly seen = new Map<string, number>();
+  private readonly ttlMs: number;
+
+  constructor(ttlMs = DEFAULT_TTL_MS) {
+    this.ttlMs = ttlMs;
+  }
+
+  isDuplicate(accountId: string, messageId: string): boolean {
+    this.gc();
+    const key = `${accountId}:${messageId}`;
+    const now = Date.now();
+    const expiresAt = this.seen.get(key);
+    if (expiresAt && expiresAt > now) {
+      return true;
+    }
+    this.seen.set(key, now + this.ttlMs);
+    return false;
+  }
+
+  private gc(): void {
+    const now = Date.now();
+    for (const [key, expiresAt] of this.seen.entries()) {
+      if (expiresAt <= now) {
+        this.seen.delete(key);
+      }
+    }
+  }
+}

package/src/gateway.ts

@@ -0,0 +1,237 @@
+import { DDCHAT_PLUGIN_WS_BASE_URL } from "./constants.js";
+import { processDdchatInboundWithChannelRuntime } from "./inbound.js";
+import { setDdchatWsRuntime } from "./runtime.js";
+import type { DdchatResolvedAccount } from "./types.js";
+
+function createReconnectDelayMs(attempt: number): number {
+  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") {
+      setDdchatWsRuntime({ connected: false, send: undefined });
+      ctx.setStatus({
+        accountId: ctx.accountId,
+        running: true,
+        connected: true,
+        reconnectAttempts: 0,
+        heartbeatSec: ctx.account.heartbeatSec,
+        inboundMode: "webhook",
+      });
+      await new Promise<void>((resolve) => {
+        const timer = setInterval(() => {
+          if (ctx.abortSignal.aborted) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 1000);
+      });
+      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<void>((resolve) => setTimeout(resolve, reconnectDelay));
+    }
+  },
+  stopAccount: async (ctx) => {
+    setDdchatWsRuntime({ connected: false, send: undefined });
+    ctx.setStatus({
+      accountId: ctx.accountId,
+      running: false,
+      connected: false,
+    });
+    ctx.log?.info?.(`[ddchat:${ctx.accountId}] stopped`);
+  },
+};
+
+function appendDdchatAuthQuery(wsUrl: string, token: string): string {
+  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: string): string {
+  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: {
+  ctx: {
+    accountId: string;
+    account: DdchatResolvedAccount;
+    cfg: Record<string, unknown>;
+    channelRuntime?: {
+      reply: Record<string, unknown>;
+      routing: Record<string, unknown>;
+      media: Record<string, unknown>;
+    };
+    abortSignal: AbortSignal;
+    setStatus: (next: Record<string, unknown>) => void;
+    log?: { info?: (m: string) => void; warn?: (m: string) => void; error?: (m: string) => void };
+  };
+  wsUrl: string;
+  wsUrlForLog: string;
+  attempts: number;
+}): Promise<void> {
+  const { ctx, wsUrl, wsUrlForLog, attempts } = params;
+  await new Promise<void>((resolve, reject) => {
+    const WebSocketCtor = (
+      globalThis as unknown as {
+        WebSocket?: new (url: string) => {
+          readyState: number;
+          send: (data: string) => void;
+          close: () => void;
+          addEventListener: (name: string, fn: (...args: never[]) => void) => void;
+        };
+      }
+    ).WebSocket;
+    if (!WebSocketCtor) {
+      reject(new Error("WebSocket is not available in this runtime"));
+      return;
+    }
+    const ws = new WebSocketCtor(wsUrl);
+    let heartbeatTimer: ReturnType<typeof setInterval> | undefined;
+    let settled = false;
+    const finish = (fn: () => void) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+      }
+      setDdchatWsRuntime({ connected: false, send: undefined });
+      fn();
+    };
+
+    ws.addEventListener("open", () => {
+      ctx.log?.info?.(`[ddchat:${ctx.accountId}] ws connected -> ${wsUrlForLog}`);
+      setDdchatWsRuntime({
+        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: "plugin" }));
+        }
+      }, Math.max(1000, ctx.account.heartbeatSec * 1000));
+    });
+
+    ws.addEventListener("message", async (event) => {
+      try {
+        const raw = typeof event.data === "string" ? event.data : String(event.data);
+        const message = JSON.parse(raw) as Record<string, unknown>;
+        if (message.type === "ping") {
+          ws.send(JSON.stringify({ type: "pong", ts: Date.now(), from: "plugin" }));
+          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 as never,
+          cfg: ctx.cfg as never,
+          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: "plugin", result }));
+        }
+      } catch (error) {
+        ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws message handling failed: ${String(error)}`);
+      }
+    });
+
+    ws.addEventListener("error", (event) => {
+      ctx.log?.warn?.(`[ddchat:${ctx.accountId}] ws error: ${String((event as 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 },
+    );
+  });
+}