ddchat 0.4.1 → 0.4.2

package/src/outbound.ts

@@ -0,0 +1,183 @@
+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

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

package/src/runtime.ts

@@ -0,0 +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 {
+  // 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

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

package/src/types.ts

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

package/task/BLOCKERS.md

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

package/task/DOING.md

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

package/task/DONE.md

@@ -0,0 +1,8 @@
+# DONE
+
+- [x] Created `ddchat/task` workflow files (`README/TODO/DOING/DONE/BLOCKERS`)
+  - Date: 2026-04-01
+  - Verification: files exist under `ddchat/task/`
+- [x] Initialized DDChat plugin skeleton and websocket-first runtime scaffold
+  - Date: 2026-04-01
+  - Verification: `ddchat/package.json`, `ddchat/openclaw.plugin.json`, and `ddchat/src/*` core files created

package/task/README.md

@@ -0,0 +1,17 @@
+# DDChat Task Records
+
+This directory tracks development progress for the `ddchat` plugin.
+
+## Files
+
+- `TODO.md`: all pending tasks
+- `DOING.md`: the single task currently in progress
+- `DONE.md`: completed tasks with verification notes
+- `BLOCKERS.md`: blockers, decisions, and risks
+
+## Workflow
+
+1. Move one item from `TODO.md` to `DOING.md` before coding.
+2. When finished, move it to `DONE.md` with date and verification notes.
+3. If blocked, add details to `BLOCKERS.md` and stop starting new work.
+4. Keep `DOING.md` to one active task only.

package/task/TODO.md

@@ -0,0 +1,10 @@
+# TODO
+
+- [ ] Finalize plugin skeleton (`package.json`, `openclaw.plugin.json`, `index.ts`, `setup-entry.ts`)
+- [ ] Implement Feishu-style multi-account config (`channels.ddchat.accounts.*`)
+- [ ] Implement websocket inbound loop (webhook reserved only)
+- [ ] Implement inbound routing for `group` (groupId) and `direct` (userId)
+- [ ] Implement inbound text + file/image handling (base64/url -> saveMediaBuffer)
+- [ ] Implement chunk-level streaming push; keep token-level mode as reserved option
+- [ ] Add compatibility notes for future plugin rename
+- [ ] Add minimal tests for route/media parsing and duplicate suppression

package/test/README.md

@@ -0,0 +1,48 @@
+# DDChat Local Mock IM
+
+Local WebSocket IM simulator for testing the `ddchat` plugin.
+
+## Start
+
+From repo root:
+
+```bash
+node ddchat/test/server.mjs
+```
+
+Then open:
+
+- UI: `http://127.0.0.1:9020`
+- WS endpoint for plugin: `ws://127.0.0.1:9001` (override plugin `constants.ts` for local dev, or run against your mock URL)
+
+## Plugin config example
+
+```json
+{
+  "channels": {
+    "ddchat": {
+      "defaultAccount": "xkx",
+      "accounts": {
+        "xkx": {
+          "enabled": true,
+          "token": "your-plugin-token",
+          "connectionMode": "websocket",
+          "wsUrl": "ws://127.0.0.1:9001",
+          "dmPolicy": "open",
+          "groupPolicy": "open",
+          "requireMention": false,
+          "streaming": true,
+          "streamingMode": "chunk"
+        }
+      }
+    }
+  }
+}
+```
+
+## Features
+
+- Send direct/group inbound message payloads.
+- Upload files/images from browser (sent as base64 in `files[]`).
+- Optional URL-based file input.
+- View stream chunks (`stream_chunk`) and final outbound messages.