ddchat 0.4.1 → 0.4.2

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 },
+    );
+  });
+}

package/src/inbound.ts

@@ -0,0 +1,394 @@
+import type { IncomingMessage } from "node:http";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { DDCHAT_CHANNEL_ID } from "./constants.js";
+import { resolveDdchatOutboundMediaFields } from "./outbound.js";
+import { getDdchatState } from "./runtime.js";
+import { resolveDdchatAccount } from "./types.js";
+
+type InboundReq = IncomingMessage & { body?: unknown; rawBody?: unknown };
+
+type DdchatInboundFile = {
+  name?: string;
+  type?: string;
+  mimeType?: string;
+  base64?: string;
+  url?: string;
+};
+
+type DdchatInboundPayload = {
+  accountId?: string;
+  messageId?: string;
+  chatType?: "direct" | "group";
+  userId?: string;
+  groupId?: string;
+  text?: string;
+  files?: DdchatInboundFile[];
+  // legacy compatibility fields
+  mediaUrl?: string;
+  mediaType?: string;
+  mediaName?: string;
+  type?: "text" | "image" | "file" | "audio";
+};
+
+function parseBodyLike(raw: unknown): DdchatInboundPayload {
+  if (!raw) {
+    return {};
+  }
+  if (typeof raw === "object" && !Buffer.isBuffer(raw)) {
+    return raw as DdchatInboundPayload;
+  }
+  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 as DdchatInboundPayload) : {};
+  } catch {
+    return {};
+  }
+}
+
+async function readRawBodyFromStream(req: IncomingMessage): Promise<string> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+async function readBody(req: InboundReq): Promise<DdchatInboundPayload> {
+  const direct = req.rawBody ?? req.body;
+  if (direct !== undefined) {
+    return parseBodyLike(direct);
+  }
+  const rawText = await readRawBodyFromStream(req);
+  return parseBodyLike(rawText);
+}
+
+function resolveMediaFetchMaxBytes(
+  cfg: ReturnType<OpenClawPluginApi["runtime"]["config"]["loadConfig"]>,
+): number | undefined {
+  const mb = cfg.agents?.defaults?.mediaMaxMb;
+  if (!mb || mb <= 0) {
+    return undefined;
+  }
+  return mb * 1024 * 1024;
+}
+
+function resolveInboundIdentity(body: DdchatInboundPayload): {
+  messageId: string;
+  chatType: "direct" | "group";
+  userId: string;
+  groupId?: string;
+} {
+  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 toInboundFiles(body: DdchatInboundPayload): DdchatInboundFile[] {
+  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: {
+  channelRuntime: OpenClawPluginApi["runtime"]["channel"];
+  cfg: ReturnType<OpenClawPluginApi["runtime"]["config"]["loadConfig"]>;
+  files: DdchatInboundFile[];
+  logInfo?: (message: string) => void;
+}): Promise<Array<{ path: string; contentType?: string }>> {
+  const out: Array<{ path: string; contentType?: string }> = [];
+  const maxBytes = resolveMediaFetchMaxBytes(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: Buffer;
+      let contentType = mediaType;
+      if (base64) {
+        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: Array<{ contentType?: string }>): string {
+  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: Array<{ path: string; contentType?: string }>,
+): {
+  MediaPath?: string;
+  MediaType?: string;
+  MediaUrl?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+} {
+  const first = mediaList[0];
+  const mediaPaths = mediaList.map((media) => media.path);
+  const mediaTypes = mediaList.map((media) => media.contentType).filter(Boolean) as string[];
+  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,
+  };
+}
+
+export function registerDdchatWebhook(api: OpenClawPluginApi): void {
+  api.registerHttpRoute({
+    path: "/ddchat/webhook",
+    auth: "plugin",
+    handler: async (req, res) => {
+      try {
+        const body = await readBody(req as InboundReq);
+        const result = await processDdchatInboundWithChannelRuntime({
+          channelRuntime: api.runtime.channel,
+          cfg: api.runtime.config.loadConfig(),
+          body,
+          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: {
+  channelRuntime: OpenClawPluginApi["runtime"]["channel"];
+  cfg: ReturnType<OpenClawPluginApi["runtime"]["config"]["loadConfig"]>;
+  body: unknown;
+  fallbackAccountId?: string;
+  source?: "webhook" | "ws";
+  logInfo?: (message: string) => void;
+}): Promise<
+  | { ok: true; duplicate: true; messageId: string; accountId: string }
+  | { ok: true; sessionKey: string; agentId: string; deliveredCount: number; delivered: Array<{ messageId?: string; text?: string }> }
+> {
+  const body = parseBodyLike(params.body);
+  const accountId = String(body.accountId ?? params.fallbackAccountId ?? "default").trim() || "default";
+  const account = resolveDdchatAccount(params.cfg, accountId);
+  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" as const, id: identity.groupId! }
+    : { kind: "direct" as const, 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: Array<{ messageId?: string; text?: string }> = [];
+  const streamId = `ddchat-stream-${identity.messageId}`;
+  let streamText = "";
+  const streamMode = account.streamingMode;
+  const emitStream = (patch: { delta?: string; done: boolean }) => {
+    getDdchatState().wsSend?.({
+      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: "plugin",
+      ts: Date.now(),
+    });
+  };
+
+  await params.channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg: params.cfg,
+    dispatcherOptions: {
+      deliver: async (payload: {
+        text?: string;
+        body?: string;
+        mediaUrl?: string;
+        mediaUrls?: string[];
+      }) => {
+        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: "plugin",
+          channel: DDCHAT_CHANNEL_ID,
+          accountId: account.accountId,
+          targetType: identity.chatType,
+          targetId: identity.chatType === "group" ? identity.groupId : identity.userId,
+          text,
+          mediaUrl,
+          ...mediaFields,
+        };
+        let sent = false;
+        if (!account.streaming || !text) {
+          sent = getDdchatState().wsSend?.(outbound) ?? false;
+        }
+        delivered.push({
+          messageId: `ddchat-out-${Date.now()}`,
+          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,
+  };
+}