ddchat 0.3.0 → 0.4.1

package/OPTIMIZATION.md

@@ -1,129 +0,0 @@
-# DDChat 插件优化记录
-
-本文按实施优先级记录当前代码中的优化项。状态说明：`已完成` 表示本轮已落地；`待后续` 表示仍建议单独评估或实施。
-
-## P0：正确性与安全边界
-
-### 1. 多账户 WebSocket 运行态为全局单例（已完成）
-
-**文件：** `src/runtime.ts`、`src/gateway.ts`、`src/outbound.ts`、`src/inbound.ts`
-
-当前 `wsSend` 和 `wsConnected` 是全局唯一状态，但插件支持多账户。多个账户同时连接 WebSocket 时，后启动账户会覆盖前一个账户的发送函数，导致出站消息和流式消息可能发到错误连接。
-
-**建议：** 将 WebSocket 运行态改为按 `accountId` 存储，例如 `Map<accountId, { connected, send }>`；出站文本、媒体、流式 chunk、入站 reply delivery 都按账户取对应发送函数。停止某个账户时只清理该账户状态。
-
-### 2. WebSocket 入站失败缺少 nack（已完成）
-
-**文件：** `src/gateway.ts`
-
-WebSocket `message` handler 处理失败时目前只记录日志，不向 DDChat 端返回失败确认。调用方无法区分“仍在处理”“已失败”“消息被丢弃”。
-
-**建议：** 在处理异常时，如果连接仍打开，发送 `ack` 且 `ok:false`，包含 `from:"plugin"`、`accountId`、`messageId`（如可解析）和简短错误信息。
-
-### 3. 入站未拒绝禁用账户（已完成）
-
-**文件：** `src/inbound.ts`
-
-入站处理解析账户后没有检查 `account.enabled`。禁用账户仍可能通过 webhook 或已有 WebSocket 路径进入后续路由。
-
-**建议：** 在 dedupe 前检查 `account.enabled`，禁用账户直接拒绝，避免消息被记录为已处理。
-
-### 4. Webhook 请求体无最大读取限制（已完成）
-
-**文件：** `src/inbound.ts`
-
-`readRawBodyFromStream` 会将整个请求体读入内存，没有上限。异常大请求可能造成内存压力。
-
-**建议：** 增加 webhook body 最大字节数，读取 stream 时累计字节数并在超限时中止处理。
-
-### 5. Base64 媒体解码前未做大小预检（已完成）
-
-**文件：** `src/inbound.ts`
-
-入站 base64 媒体会先 `Buffer.from(base64, "base64")` 完整解码，再交给 `saveMediaBuffer` 校验大小。超大 base64 会先消耗内存。
-
-**建议：** 解码前根据 base64 长度预估 decoded size，超过 `mediaMaxMb` 时直接拒绝该媒体，保留保存阶段的二次校验。
-
-## P1：可靠性和可观测性
-
-### 6. 去重 GC 每次全量扫描（已完成）
-
-**文件：** `src/dedupe.ts`
-
-`isDuplicate()` 每次调用都会遍历整个 Map 清理过期项。高频消息场景下会线性退化。
-
-**建议：** 按时间间隔或调用次数触发 GC，例如每 60 秒或每 1000 次检查清理一次，同时保持过期 key 被覆盖的现有语义。
-
-### 7. messageId 使用 Date.now() 存在碰撞风险（已完成）
-
-**文件：** `src/outbound.ts`、`src/inbound.ts`
-
-`ddchat-text-${Date.now()}`、`ddchat-media-${Date.now()}`、`ddchat-out-${Date.now()}` 在同毫秒并发下可能重复。
-
-**建议：** 使用 `crypto.randomUUID()` 或时间戳 + 进程内自增计数器生成后缀，保留现有前缀。
-
-### 8. 出站日志过多且可能泄露内容（已完成）
-
-**文件：** `src/outbound.ts`
-
-当前出站路径使用 `console.log/error` 打印连接状态、完整 payload、媒体路径和加载细节。完整 payload 可能包含用户消息、媒体 URL、本地路径或大体积字段。
-
-**建议：** 移除调试日志，或只保留不含正文/base64/token 的简短错误信息；避免打印完整 payload、text、mediaBase64。
-
-### 9. 流式/非流式发送失败反馈不足（已完成）
-
-**文件：** `src/inbound.ts`
-
-流式发送使用可选链，WebSocket 断开时会静默丢失；非流式 reply delivery 计算了 `sent` 但没有使用结果。
-
-**建议：** 按账户发送并检查返回值；失败时至少记录简短日志，避免静默丢失。
-
-## P2：配置一致性和维护性
-
-### 10. Webhook 模式使用轮询等待停止（已完成）
-
-**文件：** `src/gateway.ts`
-
-Webhook 模式通过 `setInterval` 每秒检查 `abortSignal.aborted`。
-
-**建议：** 改为监听 `abortSignal` 的 `abort` 事件，避免无意义轮询并提升停止响应速度。
-
-### 11. webhookPath 配置未生效（已完成）
-
-**文件：** `src/inbound.ts`、`src/types.ts`
-
-`types.ts` 解析了 `webhookPath`，但注册 HTTP 路由时硬编码 `/ddchat/webhook`。用户配置自定义路径不会生效。
-
-**建议：** 注册默认路径，并从当前配置收集账户级 `webhookPath` 去重注册；非法路径回退默认路径。若某路径唯一映射到一个账户，可作为该 route 的 fallback account。
-
-### 12. webhookPort 配置未被使用（待后续）
-
-**文件：** `src/types.ts`
-
-`webhookPort` 被解析但当前插件入口只注册 SDK HTTP route，并未自行监听端口。
-
-**建议：** 如果 SDK route 不支持插件自管端口，应移除或标记为暂不支持，避免误导配置使用者。
-
-### 13. mediaMaxMb 解析逻辑重复（已完成）
-
-**文件：** `src/inbound.ts`、`src/outbound.ts`
-
-入站和出站分别实现了相同的 `agents.defaults.mediaMaxMb` 解析逻辑。
-
-**建议：** 提取共享 helper，例如 `resolveDdchatMediaMaxBytes(cfg)`，统一供入站、出站、大小预检使用。
-
-### 14. gateway 上下文和 WebSocket 类型可进一步收敛（待后续）
-
-**文件：** `src/gateway.ts`
-
-`runWsSession` 手写了较多 ctx 类型并使用了类型断言。长期看容易和 SDK 类型不同步。
-
-**建议：** 若 SDK 暴露对应 gateway context 类型，则复用；否则保留本地最小类型，不为类型美化引入行为风险。
-
-### 15. session.ts 当前未被引用（待后续）
-
-**文件：** `src/session.ts`
-
-当前会话路由使用 SDK 的 `resolveAgentRoute`，`buildDdchatSessionKey` 未被项目引用。
-
-**建议：** 确认是否属于外部可用 API；如果不是，后续可单独移除，避免误导维护者。

package/README.md

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

package/setup-entry.ts

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

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,51 +0,0 @@
-const DEFAULT_TTL_MS = 48 * 60 * 60 * 1000;
-const DEFAULT_GC_INTERVAL_MS = 60 * 1000;
-const DEFAULT_GC_CHECK_INTERVAL = 1000;
-
-export class DdchatDedupeStore {
-  private readonly seen = new Map<string, number>();
-  private readonly ttlMs: number;
-  private lastGcAt = 0;
-  private checksSinceGc = 0;
-
-  constructor(
-    ttlMs = DEFAULT_TTL_MS,
-    private readonly gcIntervalMs = DEFAULT_GC_INTERVAL_MS,
-    private readonly gcCheckInterval = DEFAULT_GC_CHECK_INTERVAL,
-  ) {
-    this.ttlMs = ttlMs;
-  }
-
-  isDuplicate(accountId: string, messageId: string): boolean {
-    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;
-  }
-
-  private gcIfNeeded(now: number): void {
-    this.checksSinceGc += 1;
-    if (
-      now - this.lastGcAt < this.gcIntervalMs &&
-      this.checksSinceGc < this.gcCheckInterval
-    ) {
-      return;
-    }
-    this.lastGcAt = now;
-    this.checksSinceGc = 0;
-    this.gc(now);
-  }
-
-  private gc(now: number): void {
-    for (const [key, expiresAt] of this.seen.entries()) {
-      if (expiresAt <= now) {
-        this.seen.delete(key);
-      }
-    }
-  }
-}

package/src/gateway.ts

@@ -1,255 +0,0 @@
-import { DDCHAT_PLUGIN_WS_BASE_URL } from "./constants.js";
-import { processDdchatInboundWithChannelRuntime } from "./inbound.js";
-import { clearDdchatWsRuntime, 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") {
-      clearDdchatWsRuntime(ctx.accountId);
-      ctx.setStatus({
-        accountId: ctx.accountId,
-        running: true,
-        connected: true,
-        reconnectAttempts: 0,
-        heartbeatSec: ctx.account.heartbeatSec,
-        inboundMode: "webhook",
-      });
-      await new Promise<void>((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<void>((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: 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);
-      }
-      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: string; messageId?: string } = { accountId: ctx.accountId };
-      try {
-        const raw = typeof event.data === "string" ? event.data : String(event.data);
-        const message = JSON.parse(raw) as Record<string, unknown>;
-        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 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: "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 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 },
-    );
-  });
-}