ddchat 0.1.0 → 0.2.0

package/src/outbound.ts

@@ -1,95 +1,183 @@
-import { loadWebMedia } from "openclaw/plugin-sdk/media-runtime";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { DDCHAT_CHANNEL_ID } from "./constants.js";
-import { getDdchatState } from "./runtime.js";
-
-function resolveMediaMaxBytes(cfg: OpenClawConfig): number | undefined {
-  const mb = cfg.agents?.defaults?.mediaMaxMb;
-  if (!mb || mb <= 0) {
-    return undefined;
-  }
-  return mb * 1024 * 1024;
-}
-
-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);
-    const payload = {
-      type: "outbound_message",
-      from: "plugin",
-      channel: DDCHAT_CHANNEL_ID,
-      accountId,
-      messageId,
-      targetType: target.targetType,
-      targetId: target.targetId,
-      text,
-    };
-    const sent = getDdchatState().wsSend?.(payload) ?? false;
-    return {
-      messageId,
-      to,
-      channel: DDCHAT_CHANNEL_ID,
-      text,
-      transport: sent ? "ws" : "mock",
-    };
-  },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
-    const messageId = `ddchat-media-${Date.now()}`;
-    const target = resolveTarget(to);
-    let mediaBase64: string | undefined;
-    let mediaType: string | undefined;
-    let mediaName: string | undefined;
-    try {
-      const media = await loadWebMedia(mediaUrl, {
-        maxBytes: resolveMediaMaxBytes(cfg),
-      });
-      mediaBase64 = media.buffer.toString("base64");
-      mediaType = media.contentType;
-      mediaName = media.fileName;
-    } catch {
-      // Keep URL-only fallback for remote/local unsupported cases.
-    }
-    const payload = {
-      type: "outbound_message",
-      channel: DDCHAT_CHANNEL_ID,
-      accountId,
-      messageId,
-      targetType: target.targetType,
-      targetId: target.targetId,
-      text,
-      mediaUrl,
-      mediaBase64,
-      mediaType,
-      mediaName,
-    };
-    const sent = getDdchatState().wsSend?.(payload) ?? false;
-    return {
-      messageId,
-      to,
-      channel: DDCHAT_CHANNEL_ID,
-      text,
-      mediaUrl,
-      mediaType,
-      mediaName,
-      transport: sent ? "ws" : "mock",
-    };
-  },
-};
+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 +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,24 +1,27 @@
-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 {
-  return state;
-}
-
-export function setDdchatWsRuntime(params: {
-  send?: (payload: Record<string, unknown>) => boolean;
-  connected: boolean;
-}): void {
-  state.wsSend = params.send;
-  state.wsConnected = params.connected;
-}
+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 +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}`;
+}

package/src/types.ts

@@ -1,126 +1,126 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { DDCHAT_CHANNEL_ID, DDCHAT_DEFAULT_ACCOUNT_ID } from "./constants.js";
-
-export type DdchatStreamingMode = "chunk" | "token";
-export type DdchatConnectionMode = "websocket" | "webhook";
-export type DdchatPolicy = "open" | "pairing" | "allowlist";
-
-export type DdchatResolvedAccount = {
-  accountId: string;
-  enabled: boolean;
-  configured: boolean;
-  token?: string;
-  wsUrl?: string;
-  webhookPath?: string;
-  webhookPort?: number;
-  connectionMode: DdchatConnectionMode;
-  dmPolicy: DdchatPolicy;
-  groupPolicy: "open" | "allowlist" | "disabled";
-  requireMention: boolean;
-  streaming: boolean;
-  streamingMode: DdchatStreamingMode;
-  allowFrom: string[];
-  groupAllowFrom: string[];
-  heartbeatSec: number;
-};
-
-type DdchatAccountConfig = {
-  enabled?: boolean;
-  token?: string;
-  wsUrl?: string;
-  webhookPath?: string;
-  webhookPort?: number;
-  connectionMode?: DdchatConnectionMode;
-  dmPolicy?: DdchatPolicy;
-  groupPolicy?: "open" | "allowlist" | "disabled";
-  requireMention?: boolean;
-  streaming?: boolean;
-  streamingMode?: DdchatStreamingMode;
-  allowFrom?: Array<string | number>;
-  groupAllowFrom?: Array<string | number>;
-  heartbeatSec?: number;
-};
-
-type DdchatChannelConfig = DdchatAccountConfig & {
-  defaultAccount?: string;
-  accounts?: Record<string, DdchatAccountConfig | undefined>;
-};
-
-function toStringList(input: Array<string | number> | undefined): string[] {
-  if (!input) {
-    return [];
-  }
-  return input.map((entry) => String(entry).trim()).filter(Boolean);
-}
-
-function normalizeConnectionMode(mode: string | undefined): DdchatConnectionMode {
-  return mode === "webhook" ? "webhook" : "websocket";
-}
-
-function normalizeStreamingMode(mode: string | undefined): DdchatStreamingMode {
-  return mode === "token" ? "token" : "chunk";
-}
-
-function readChannelConfig(cfg: OpenClawConfig): DdchatChannelConfig {
-  return ((cfg.channels as Record<string, unknown> | undefined)?.[DDCHAT_CHANNEL_ID] ?? {}) as DdchatChannelConfig;
-}
-
-function mergeAccountConfig(params: {
-  root: DdchatChannelConfig;
-  account?: DdchatAccountConfig;
-}): DdchatAccountConfig {
-  const { root, account } = params;
-  return {
-    ...root,
-    ...account,
-  };
-}
-
-export function listDdchatAccountIds(cfg: OpenClawConfig): string[] {
-  const channelCfg = readChannelConfig(cfg);
-  const keys = Object.keys(channelCfg.accounts ?? {}).filter((key) => key.trim().length > 0);
-  return keys.length > 0 ? keys : [DDCHAT_DEFAULT_ACCOUNT_ID];
-}
-
-export function resolveDefaultDdchatAccountId(cfg: OpenClawConfig): string {
-  const channelCfg = readChannelConfig(cfg);
-  const ids = listDdchatAccountIds(cfg);
-  const configured = channelCfg.defaultAccount?.trim();
-  return configured && ids.includes(configured) ? configured : ids[0];
-}
-
-export function resolveDdchatAccount(
-  cfg: OpenClawConfig,
-  accountId?: string | null,
-): DdchatResolvedAccount {
-  const channelCfg = readChannelConfig(cfg);
-  const resolvedAccountId = accountId?.trim() || resolveDefaultDdchatAccountId(cfg);
-  const named = channelCfg.accounts?.[resolvedAccountId];
-  const merged = mergeAccountConfig({ root: channelCfg, account: named });
-  const token = typeof merged.token === "string" ? merged.token.trim() : "";
-  const wsUrl = typeof merged.wsUrl === "string" ? merged.wsUrl.trim() : "";
-  return {
-    accountId: resolvedAccountId,
-    enabled: merged.enabled !== false,
-    configured: Boolean(token),
-    token: token || undefined,
-    wsUrl: wsUrl || undefined,
-    webhookPath:
-      typeof merged.webhookPath === "string" && merged.webhookPath.trim()
-        ? merged.webhookPath.trim()
-        : "/ddchat/webhook",
-    webhookPort:
-      typeof merged.webhookPort === "number" && Number.isFinite(merged.webhookPort)
-        ? merged.webhookPort
-        : 3010,
-    connectionMode: normalizeConnectionMode(merged.connectionMode),
-    dmPolicy: merged.dmPolicy ?? "pairing",
-    groupPolicy: merged.groupPolicy ?? "allowlist",
-    requireMention: merged.requireMention === true,
-    streaming: merged.streaming !== false,
-    streamingMode: normalizeStreamingMode(merged.streamingMode),
-    allowFrom: toStringList(merged.allowFrom),
-    groupAllowFrom: toStringList(merged.groupAllowFrom),
-    heartbeatSec: Math.max(15, Number(merged.heartbeatSec ?? 60) || 60),
-  };
-}
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { DDCHAT_CHANNEL_ID, DDCHAT_DEFAULT_ACCOUNT_ID } from "./constants.js";
+
+export type DdchatStreamingMode = "chunk" | "token";
+export type DdchatConnectionMode = "websocket" | "webhook";
+export type DdchatPolicy = "open" | "pairing" | "allowlist";
+
+export type DdchatResolvedAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  token?: string;
+  wsUrl?: string;
+  webhookPath?: string;
+  webhookPort?: number;
+  connectionMode: DdchatConnectionMode;
+  dmPolicy: DdchatPolicy;
+  groupPolicy: "open" | "allowlist" | "disabled";
+  requireMention: boolean;
+  streaming: boolean;
+  streamingMode: DdchatStreamingMode;
+  allowFrom: string[];
+  groupAllowFrom: string[];
+  heartbeatSec: number;
+};
+
+type DdchatAccountConfig = {
+  enabled?: boolean;
+  token?: string;
+  wsUrl?: string;
+  webhookPath?: string;
+  webhookPort?: number;
+  connectionMode?: DdchatConnectionMode;
+  dmPolicy?: DdchatPolicy;
+  groupPolicy?: "open" | "allowlist" | "disabled";
+  requireMention?: boolean;
+  streaming?: boolean;
+  streamingMode?: DdchatStreamingMode;
+  allowFrom?: Array<string | number>;
+  groupAllowFrom?: Array<string | number>;
+  heartbeatSec?: number;
+};
+
+type DdchatChannelConfig = DdchatAccountConfig & {
+  defaultAccount?: string;
+  accounts?: Record<string, DdchatAccountConfig | undefined>;
+};
+
+function toStringList(input: Array<string | number> | undefined): string[] {
+  if (!input) {
+    return [];
+  }
+  return input.map((entry) => String(entry).trim()).filter(Boolean);
+}
+
+function normalizeConnectionMode(mode: string | undefined): DdchatConnectionMode {
+  return mode === "webhook" ? "webhook" : "websocket";
+}
+
+function normalizeStreamingMode(mode: string | undefined): DdchatStreamingMode {
+  return mode === "token" ? "token" : "chunk";
+}
+
+function readChannelConfig(cfg: OpenClawConfig): DdchatChannelConfig {
+  return ((cfg.channels as Record<string, unknown> | undefined)?.[DDCHAT_CHANNEL_ID] ?? {}) as DdchatChannelConfig;
+}
+
+function mergeAccountConfig(params: {
+  root: DdchatChannelConfig;
+  account?: DdchatAccountConfig;
+}): DdchatAccountConfig {
+  const { root, account } = params;
+  return {
+    ...root,
+    ...account,
+  };
+}
+
+export function listDdchatAccountIds(cfg: OpenClawConfig): string[] {
+  const channelCfg = readChannelConfig(cfg);
+  const keys = Object.keys(channelCfg.accounts ?? {}).filter((key) => key.trim().length > 0);
+  return keys.length > 0 ? keys : [DDCHAT_DEFAULT_ACCOUNT_ID];
+}
+
+export function resolveDefaultDdchatAccountId(cfg: OpenClawConfig): string {
+  const channelCfg = readChannelConfig(cfg);
+  const ids = listDdchatAccountIds(cfg);
+  const configured = channelCfg.defaultAccount?.trim();
+  return configured && ids.includes(configured) ? configured : ids[0];
+}
+
+export function resolveDdchatAccount(
+  cfg: OpenClawConfig,
+  accountId?: string | null,
+): DdchatResolvedAccount {
+  const channelCfg = readChannelConfig(cfg);
+  const resolvedAccountId = accountId?.trim() || resolveDefaultDdchatAccountId(cfg);
+  const named = channelCfg.accounts?.[resolvedAccountId];
+  const merged = mergeAccountConfig({ root: channelCfg, account: named });
+  const token = typeof merged.token === "string" ? merged.token.trim() : "";
+  const wsUrl = typeof merged.wsUrl === "string" ? merged.wsUrl.trim() : "";
+  return {
+    accountId: resolvedAccountId,
+    enabled: merged.enabled !== false,
+    configured: Boolean(token),
+    token: token || undefined,
+    wsUrl: wsUrl || undefined,
+    webhookPath:
+      typeof merged.webhookPath === "string" && merged.webhookPath.trim()
+        ? merged.webhookPath.trim()
+        : "/ddchat/webhook",
+    webhookPort:
+      typeof merged.webhookPort === "number" && Number.isFinite(merged.webhookPort)
+        ? merged.webhookPort
+        : 3010,
+    connectionMode: normalizeConnectionMode(merged.connectionMode),
+    dmPolicy: merged.dmPolicy ?? "pairing",
+    groupPolicy: merged.groupPolicy ?? "allowlist",
+    requireMention: merged.requireMention === true,
+    streaming: merged.streaming !== false,
+    streamingMode: normalizeStreamingMode(merged.streamingMode),
+    allowFrom: toStringList(merged.allowFrom),
+    groupAllowFrom: toStringList(merged.groupAllowFrom),
+    heartbeatSec: Math.max(15, Number(merged.heartbeatSec ?? 60) || 60),
+  };
+}

package/task/BLOCKERS.md

@@ -1,3 +1,3 @@
-# BLOCKERS
-
-- None currently.
+# BLOCKERS
+
+- None currently.

package/task/DOING.md

@@ -1,3 +1,3 @@
-# DOING
-
-- [ ] Implement websocket-first inbound and chunk streaming for multi-account `ddchat`
+# DOING
+
+- [ ] Implement websocket-first inbound and chunk streaming for multi-account `ddchat`