ddchat 0.2.0 → 0.4.0

package/src/inbound.ts

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

package/src/outbound.ts

@@ -1,183 +0,0 @@
-import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { DDCHAT_CHANNEL_ID } from "./constants.js";
-import { getDdchatState } from "./runtime.js";
-import { pathToFileURL } from "url";
-
-function resolveMediaMaxBytes(cfg: OpenClawConfig): number | undefined {
-  const mb = cfg.agents?.defaults?.mediaMaxMb;
-  if (!mb || mb <= 0) {
-    return undefined;
-  }
-  return mb * 1024 * 1024;
-}
-
-/** Check if URL is a local file path */
-function isLocalFilePath(url: string): boolean {
-  if (url.startsWith("file://")) return true;
-  if (/^[a-zA-Z]:[\\/]/.test(url)) return true; // Windows path
-  if (url.startsWith("/") && !url.startsWith("//")) return true; // Unix absolute path
-  return false;
-}
-
-/** Convert local path to file:// URL */
-function toFileUrl(path: string): string {
-  if (path.startsWith("file://")) return path;
-  return pathToFileURL(path).href;
-}
-
-/** Load media for WS outbound; same limits as sendMedia. URL-only fallback on failure. */
-export async function resolveDdchatOutboundMediaFields(
-  cfg: OpenClawConfig,
-  mediaUrl: string,
-): Promise<{ mediaBase64?: string; mediaType?: string; mediaName?: string; error?: string }> {
-  try {
-    // Handle local file paths
-    let resolvedUrl = mediaUrl;
-    if (isLocalFilePath(mediaUrl)) {
-      resolvedUrl = toFileUrl(mediaUrl);
-    }
-    console.log(`[ddchat] Resolved media URL: ${resolvedUrl}`);
-
-    const media = await loadWebMedia(resolvedUrl, {
-      maxBytes: resolveMediaMaxBytes(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 = `ddchat-text-${Date.now()}`;
-    const target = resolveTarget(to);
-    
-    // Check WebSocket connection
-    const state = getDdchatState();
-    console.log(`[ddchat] sendText called - wsConnected: ${state.wsConnected}, wsSend available: ${!!state.wsSend}`);
-    
-    if (!state.wsSend || !state.wsConnected) {
-      console.error(`[ddchat] WebSocket not connected, cannot send text message`);
-      throw new Error("DDChat WebSocket not connected");
-    }
-
-    const payload = {
-      type: "outbound_message",
-      from: "plugin",
-      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 = state.wsSend(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 = `ddchat-media-${Date.now()}`;
-    const target = resolveTarget(to);
-    
-    // Check WebSocket connection
-    const state = getDdchatState();
-    console.log(`[ddchat] sendMedia called - wsConnected: ${state.wsConnected}, wsSend available: ${!!state.wsSend}`);
-    
-    if (!state.wsSend || !state.wsConnected) {
-      console.error(`[ddchat] WebSocket not connected, cannot send media`);
-      throw new Error("DDChat WebSocket not connected");
-    }
-
-    // Load media
-    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}`);
-    }
-
-    // Validate media data
-    if (!mediaBase64) {
-      console.error(`[ddchat] No media data available for ${mediaUrl}`);
-      throw new Error("No media data available");
-    }
-
-    const payload = {
-      type: "outbound_message",
-      from: "plugin",
-      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 = state.wsSend(payload);
-    if (!sent) {
-      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,27 +0,0 @@
-import { DdchatDedupeStore } from "./dedupe.js";
-
-export type DdchatPluginRuntimeState = {
-  dedupe: DdchatDedupeStore;
-  wsSend?: (payload: Record<string, unknown>) => boolean;
-  wsConnected: boolean;
-};
-
-const state: DdchatPluginRuntimeState = {
-  dedupe: new DdchatDedupeStore(),
-  wsConnected: false,
-};
-
-export function getDdchatState(): DdchatPluginRuntimeState {
-  // console.log(`[ddchat] getDdchatState called - wsConnected: ${state.wsConnected}, wsSend available: ${!!state.wsSend}`);
-  return state;
-}
-
-export function setDdchatWsRuntime(params: {
-  send?: (payload: Record<string, unknown>) => boolean;
-  connected: boolean;
-}): void {
-  // console.log(`[ddchat] setDdchatWsRuntime called - connected: ${params.connected}, send available: ${!!params.send}`);
-  state.wsSend = params.send;
-  state.wsConnected = params.connected;
-  // console.log(`[ddchat] State updated - wsConnected: ${state.wsConnected}, wsSend available: ${!!state.wsSend}`);
-}

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}`;
-}