ddchat 0.3.0 → 0.4.1

package/src/inbound.ts

@@ -1,451 +0,0 @@
-import { randomUUID } from "node:crypto";
-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, getDdchatWsRuntime } from "./runtime.js";
-import { listDdchatAccountIds, resolveDdchatAccount, resolveDdchatMediaMaxBytes } from "./types.js";
-
-type InboundReq = IncomingMessage & { body?: unknown; rawBody?: unknown };
-
-const DEFAULT_WEBHOOK_BODY_MAX_BYTES = 10 * 1024 * 1024;
-
-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, maxBytes: number): Promise<string> {
-  const chunks: Buffer[] = [];
-  let totalBytes = 0;
-  for await (const chunk of req) {
-    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-    totalBytes += buffer.length;
-    if (totalBytes > maxBytes) {
-      throw new Error("webhook body too large");
-    }
-    chunks.push(buffer);
-  }
-  return Buffer.concat(chunks).toString("utf-8");
-}
-
-async function readBody(req: InboundReq, maxBytes = DEFAULT_WEBHOOK_BODY_MAX_BYTES): Promise<DdchatInboundPayload> {
-  const direct = req.rawBody ?? req.body;
-  if (direct !== undefined) {
-    if (Buffer.isBuffer(direct) && direct.length > maxBytes) {
-      throw new Error("webhook body too large");
-    }
-    if (typeof direct === "string" && Buffer.byteLength(direct, "utf-8") > maxBytes) {
-      throw new Error("webhook body too large");
-    }
-    return parseBodyLike(direct);
-  }
-  const rawText = await readRawBodyFromStream(req, maxBytes);
-  return parseBodyLike(rawText);
-}
-
-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 createDdchatMessageId(prefix: string): string {
-  return `${prefix}-${randomUUID()}`;
-}
-
-function estimateBase64DecodedBytes(input: string): number {
-  const normalized = input.replace(/\s/g, "");
-  const padding = normalized.endsWith("==") ? 2 : normalized.endsWith("=") ? 1 : 0;
-  return Math.floor((normalized.length * 3) / 4) - padding;
-}
-
-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 = resolveDdchatMediaMaxBytes(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) {
-        if (maxBytes && estimateBase64DecodedBytes(base64) > maxBytes) {
-          throw new Error("media exceeds maximum size");
-        }
-        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,
-  };
-}
-
-function collectWebhookRoutes(cfg: ReturnType<OpenClawPluginApi["runtime"]["config"]["loadConfig"]>): Array<{
-  path: string;
-  fallbackAccountId?: string;
-}> {
-  const byPath = new Map<string, Set<string>>();
-  const add = (path: string, accountId: string) => {
-    const accounts = byPath.get(path) ?? new Set<string>();
-    accounts.add(accountId);
-    byPath.set(path, accounts);
-  };
-  byPath.set("/ddchat/webhook", new Set());
-  for (const accountId of listDdchatAccountIds(cfg)) {
-    const account = resolveDdchatAccount(cfg, accountId);
-    add(account.webhookPath ?? "/ddchat/webhook", account.accountId);
-  }
-  return Array.from(byPath.entries()).map(([path, accounts]) => {
-    const accountIds = Array.from(accounts);
-    return {
-      path,
-      fallbackAccountId: accountIds.length === 1 ? accountIds[0] : undefined,
-    };
-  });
-}
-
-export function registerDdchatWebhook(api: OpenClawPluginApi): void {
-  const cfg = api.runtime.config.loadConfig();
-  for (const route of collectWebhookRoutes(cfg)) {
-    api.registerHttpRoute({
-      path: route.path,
-      auth: "plugin",
-      handler: async (req, res) => {
-        try {
-          const currentCfg = api.runtime.config.loadConfig();
-          const body = await readBody(req as InboundReq);
-          const result = await processDdchatInboundWithChannelRuntime({
-            channelRuntime: api.runtime.channel,
-            cfg: currentCfg,
-            body,
-            fallbackAccountId: route.fallbackAccountId,
-            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);
-  if (!account.enabled) {
-    throw new Error(`ddchat account '${account.accountId}' is disabled`);
-  }
-  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 }) => {
-    const runtime = getDdchatWsRuntime(account.accountId);
-    const sent = runtime.send?.({
-      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: "claw",
-      ts: Date.now(),
-    }) ?? false;
-    if (!sent) {
-      params.logInfo?.(`ddchat stream send failed for account ${account.accountId}`);
-    }
-  };
-
-  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: "claw",
-          channel: DDCHAT_CHANNEL_ID,
-          accountId: account.accountId,
-          targetType: identity.chatType,
-          targetId: identity.chatType === "group" ? identity.groupId : identity.userId,
-          text,
-          mediaUrl,
-          ...mediaFields,
-        };
-        if (!account.streaming || !text) {
-          const runtime = getDdchatWsRuntime(account.accountId);
-          const sent = runtime.send?.(outbound) ?? false;
-          if (!sent) {
-            params.logInfo?.(`ddchat outbound send failed for account ${account.accountId}`);
-          }
-        }
-        delivered.push({
-          messageId: createDdchatMessageId("ddchat-out"),
-          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,
-  };
-}

package/src/outbound.ts

@@ -1,167 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { pathToFileURL } from "node:url";
-import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { DDCHAT_CHANNEL_ID } from "./constants.js";
-import { getDdchatWsRuntime } from "./runtime.js";
-import { resolveDdchatMediaMaxBytes } from "./types.js";
-
-function createDdchatMessageId(prefix: string): string {
-  return `${prefix}-${randomUUID()}`;
-}
-
-function isLocalFilePath(url: string): boolean {
-  if (url.startsWith("file://")) return true;
-  if (/^[a-zA-Z]:[\\/]/.test(url)) return true;
-  if (url.startsWith("/") && !url.startsWith("//")) return true;
-  return false;
-}
-
-function toFileUrl(path: string): string {
-  if (path.startsWith("file://")) return path;
-  return pathToFileURL(path).href;
-}
-
-export async function resolveDdchatOutboundMediaFields(
-  cfg: OpenClawConfig,
-  mediaUrl: string,
-): Promise<{ mediaBase64?: string; mediaType?: string; mediaName?: string; error?: string }> {
-  try {
-    let resolvedUrl = mediaUrl;
-    if (isLocalFilePath(mediaUrl)) {
-      resolvedUrl = toFileUrl(mediaUrl);
-    }
-    console.log(`[ddchat] Resolved media URL: ${resolvedUrl}`);
-
-    const media = await loadWebMedia(resolvedUrl, {
-      maxBytes: resolveDdchatMediaMaxBytes(cfg),
-    });
-    console.log(`[ddchat] Media loaded successfully: ${media.fileName}, type: ${media.contentType}, size: ${media.buffer.length}`);
-    return {
-      mediaBase64: media.buffer.toString("base64"),
-      mediaType: media.contentType,
-      mediaName: media.fileName,
-    };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    console.error(`[ddchat] Failed to load media from ${mediaUrl}: ${errorMsg}`);
-    return { error: errorMsg };
-  }
-}
-
-function resolveTarget(to: string): { targetType: "group" | "direct"; targetId: string } {
-  const normalized = to.trim();
-  if (normalized.startsWith("group:")) {
-    return { targetType: "group", targetId: normalized.slice("group:".length) };
-  }
-  if (normalized.startsWith("chat:")) {
-    return { targetType: "group", targetId: normalized.slice("chat:".length) };
-  }
-  if (normalized.startsWith("user:")) {
-    return { targetType: "direct", targetId: normalized.slice("user:".length) };
-  }
-  return { targetType: "direct", targetId: normalized };
-}
-
-export const ddchatOutbound = {
-  deliveryMode: "direct",
-  textChunkLimit: 4000,
-  chunkerMode: "markdown",
-  sendText: async ({ to, text, accountId }) => {
-    const messageId = createDdchatMessageId("ddchat-text");
-    const target = resolveTarget(to);
-
-    const runtime = getDdchatWsRuntime(accountId);
-    if (!runtime.send || !runtime.connected) {
-      throw new Error("DDChat WebSocket not connected");
-    }
-
-    const payload = {
-      type: "outbound_message",
-      from: "claw",
-      channel: DDCHAT_CHANNEL_ID,
-      accountId,
-      messageId,
-      targetType: target.targetType,
-      targetId: target.targetId,
-      text,
-    };
-    console.log(`[ddchat] Sending text payload:`, JSON.stringify(payload, null, 2));
-    const sent = runtime.send(payload);
-    if (!sent) {
-      throw new Error("Failed to send text message via WebSocket");
-    }
-    return {
-      messageId,
-      to,
-      channel: DDCHAT_CHANNEL_ID,
-      text,
-      transport: "ws",
-    };
-  },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
-    const messageId = createDdchatMessageId("ddchat-media");
-    const target = resolveTarget(to);
-     
-    const runtime = getDdchatWsRuntime(accountId);
-    console.log(`[ddchat] sendMedia called - wsConnected: ${runtime.connected}, wsSend available: ${!!runtime.send}`);
-    if (!runtime.send || !runtime.connected) {
-      throw new Error("DDChat WebSocket not connected");
-    }
-
-    console.log(`[ddchat] Loading media from: ${mediaUrl}`);
-    const { mediaBase64, mediaType, mediaName, error } = await resolveDdchatOutboundMediaFields(
-      cfg,
-      mediaUrl,
-    );
-
-    if (error) {
-      console.error(`[ddchat] Media loading failed: ${error}`);
-      throw new Error(`Failed to load media: ${error}`);
-    }
-
-    if (!mediaBase64) {
-      console.error(`[ddchat] No media data available for ${mediaUrl}`);
-      throw new Error("No media data available");
-    }
-
-    const payload = {
-      type: "outbound_message",
-      from: "claw",
-      channel: DDCHAT_CHANNEL_ID,
-      accountId,
-      messageId,
-      targetType: target.targetType,
-      targetId: target.targetId,
-      text,
-      mediaUrl,
-      mediaBase64,
-      mediaType,
-      mediaName,
-    };
-    console.log(`[ddchat] Sending media message:`, {
-      messageId,
-      targetType: target.targetType,
-      targetId: target.targetId,
-      mediaType,
-      mediaName,
-      mediaSize: mediaBase64?.length,
-    });
-    const sent = runtime.send(payload);
-    if (!sent) {
-      console.error(`[ddchat] Failed to send media message via WebSocket`);
-      throw new Error("Failed to send media message via WebSocket");
-    }
-
-    return {
-      messageId,
-      to,
-      channel: DDCHAT_CHANNEL_ID,
-      text,
-      mediaUrl,
-      mediaType,
-      mediaName,
-      transport: "ws",
-    };
-  },
-};

package/src/pairing.ts

@@ -1,9 +0,0 @@
-import { createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
-
-export const ddchatPairing = {
-  idLabel: "ddchatUserId",
-  normalizeAllowEntry: createPairingPrefixStripper(/^(ddchat|user):/i),
-  notifyApproval: async ({ runtime, id }) => {
-    runtime?.log?.(`[ddchat] pairing approved for ${id}`);
-  },
-};

package/src/runtime.ts

@@ -1,41 +0,0 @@
-import { DdchatDedupeStore } from "./dedupe.js";
-
-export type DdchatWsSend = (payload: Record<string, unknown>) => boolean;
-
-export type DdchatWsRuntime = {
-  send?: DdchatWsSend;
-  connected: boolean;
-};
-
-export type DdchatPluginRuntimeState = {
-  dedupe: DdchatDedupeStore;
-  wsByAccount: Map<string, DdchatWsRuntime>;
-};
-
-const state: DdchatPluginRuntimeState = {
-  dedupe: new DdchatDedupeStore(),
-  wsByAccount: new Map(),
-};
-
-export function getDdchatState(): DdchatPluginRuntimeState {
-  return state;
-}
-
-export function getDdchatWsRuntime(accountId: string): DdchatWsRuntime {
-  return state.wsByAccount.get(accountId) ?? { connected: false };
-}
-
-export function setDdchatWsRuntime(params: {
-  accountId: string;
-  send?: DdchatWsSend;
-  connected: boolean;
-}): void {
-  state.wsByAccount.set(params.accountId, {
-    send: params.send,
-    connected: params.connected,
-  });
-}
-
-export function clearDdchatWsRuntime(accountId: string): void {
-  state.wsByAccount.delete(accountId);
-}

package/src/session.ts

@@ -1,19 +0,0 @@
-export function buildDdchatSessionKey(params: {
-  peerKind: "direct" | "group";
-  peerId: string;
-  senderId?: string;
-  threadId?: string | null;
-}): string {
-  const base =
-    params.peerKind === "group"
-      ? `ddchat:group:${params.peerId}`
-      : `ddchat:direct:${params.peerId}`;
-  const thread = params.threadId?.trim();
-  if (!thread) {
-    return base;
-  }
-  if (params.peerKind === "group" && params.senderId) {
-    return `${base}:thread:${thread}:sender:${params.senderId}`;
-  }
-  return `${base}:thread:${thread}`;
-}