ddchat 0.2.0 → 0.3.0

package/src/outbound.ts

@@ -1,183 +1,167 @@
-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",
-    };
-  },
-};
+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 +1,9 @@
-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}`);
-  },
-};
+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 +1,41 @@
-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}`);
-}
+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 +1,19 @@
-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}`;
-}
+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}`;
+}