ddchat 0.2.0 → 0.4.0

package/OPTIMIZATION.md

@@ -1,105 +0,0 @@
-# DDChat 插件代码优化建议
-
-## 1. 去重 GC 性能问题
-
-**文件：** `src/dedupe.ts:23-29`
-
-`gc()` 在每次 `isDuplicate()` 调用时都全量遍历整个 Map。高频消息场景下性能会线性退化。
-
-**建议：** 改为按频率限流 GC（如每 N 次调用或每 M 秒执行一次），或改用双桶/时间轮策略。
-
----
-
-## 2. 全局单例状态不支持多账户并发（功能缺陷）
-
-**文件：** `src/runtime.ts`
-
-`wsSend` 和 `wsConnected` 是全局唯一的，但插件支持多账户。如果两个账户同时启动 WebSocket，后启动的会覆盖前一个的 `wsSend`，导致第一个账户的出站消息实际发到第二个连接上。
-
-**建议：** 将 `wsSend` 改为 `Map<accountId, sendFn>` 结构，出站时按 `accountId` 查找对应的发送函数。
-
----
-
-## 3. messageId 使用 Date.now() 存在碰撞风险
-
-**文件：** `src/outbound.ts:33,55`
-
-`ddchat-text-${Date.now()}` 在高并发下可能产生重复 ID。
-
-**建议：** 加入自增计数器或使用 `crypto.randomUUID()`。
-
----
-
-## 4. Webhook 模式下的轮询等待（资源浪费）
-
-**文件：** `src/gateway.ts:29-36`
-
-Webhook 模式用 `setInterval` 每秒轮询 `abortSignal.aborted`，浪费资源。
-
-**建议：** 改为直接监听 `abortSignal` 的 `abort` 事件：
-
-```ts
-await new Promise<void>(resolve => {
-  ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
-});
-```
-
----
-
-## 5. resolveMediaMaxBytes 重复定义
-
-**文件：** `src/inbound.ts:68-76` 和 `src/outbound.ts:6-12`
-
-`inbound.ts` 的 `resolveMediaFetchMaxBytes` 和 `outbound.ts` 的 `resolveMediaMaxBytes` 逻辑完全相同。
-
-**建议：** 提取到 `types.ts` 或新建一个共享工具函数。
-
----
-
-## 6. WebSocket 构造器类型处理冗余
-
-**文件：** `src/gateway.ts:122-135`
-
-通过 `globalThis as unknown` 手动声明 WebSocket 类型，既冗长又不安全。
-
-**建议：** 使用 TypeScript 内置的 `WebSocket` 类型（TS 4.4+ 全局可用），或在文件顶部用 `/// <reference lib="dom" />` 引入，去掉手动类型断言。
-
----
-
-## 7. gateway.ts 中 ctx 类型未复用
-
-**文件：** `src/gateway.ts:102-117`
-
-`runWsSession` 的 `ctx` 参数手写了大量类型结构，���这些应该可以从 SDK 中导入。
-
-**建议：** 从 `openclaw/plugin-sdk/core` 导入网关上下文类型，避免与 SDK 类型不同步。
-
----
-
-## 8. 流式响应在 WebSocket 断开时静默丢失
-
-**文件：** `src/inbound.ts:320-334`
-
-`emitStream` 中调用 `getDdchatState().wsSend?.(...)` 使用了可选链，连接断开时流式数据无声丢失，客户端无法感知。
-
-**建议：** 至少记录一条日志，或在 `wsSend` 返回 `false` 时尝试缓冲/通知调用方。
-
----
-
-## 9. buildDdchatSessionKey 未被使用
-
-**文件：** `src/session.ts`
-
-整个 `session.ts` 导出了 `buildDdchatSessionKey` 函数，但在项目中没有任何地方引用它（路由使用的是 SDK 的 `resolveAgentRoute`）。
-
-**建议：** 确认是否为遗留代码，如果不需要则移除。
-
----
-
-## 10. Webhook 路径配置未生效
-
-**文件：** `src/inbound.ts:212` 和 `src/types.ts:108-111`
-
-`types.ts` 中解析了 `webhookPath` 和 `webhookPort` 配置，但 `registerDdchatWebhook` 硬编码了 `/ddchat/webhook` 路径，并未使用账户配置中的值。
-
-**建议：** 使用 `account.webhookPath` 注册路由，或移除 `types.ts` 中未使用的配置字段。

package/README.md

@@ -1,14 +0,0 @@
-# 本地安装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/src/channel.ts

@@ -1,101 +0,0 @@
-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/dedupe.ts

@@ -1,31 +0,0 @@
-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

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