@workclaw/openclaw-workchat 1.0.5 → 1.1.0

package/src/messaging/send-media.ts

@@ -0,0 +1,201 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import type { WorkChatApiOptions } from "../api/api.js";
+import { sendWorkChatMessage, sendWorkChatReplyMessage, uploadWorkChatFile } from "../api/api.js";
+import { assertSessionActive, pauseOnPermanentError } from "../api/session-guard.js";
+import { WorkChatMsgType } from "../api/types.js";
+import type { ResolvedWorkChatAccount } from "../auth/accounts.js";
+import { logger } from "../util/logger.js";
+import { generateId } from "../util/random.js";
+
+import { buildApiOptions, pushWorkChatMessage } from "./send.js";
+
+/** Backend FileType whitelist (tuzai FileServiceImpl rejects unknown suffixes). */
+const AUDIO_EXTENSIONS = new Set(["wav", "m4a", "mp3"]);
+
+/** True when mediaUrl refers to a local filesystem path (not a remote URL). */
+export function isLocalMediaSource(mediaUrl: string): boolean {
+  const trimmed = mediaUrl.trim();
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) return false;
+  return trimmed.startsWith("/")
+    || trimmed.startsWith("./")
+    || trimmed.startsWith("../")
+    || trimmed.startsWith("~")
+    || trimmed.startsWith("file://")
+    || path.isAbsolute(trimmed);
+}
+
+export function resolveLocalMediaPath(mediaUrl: string): string {
+  if (mediaUrl.startsWith("file://")) {
+    const parsed = new URL(mediaUrl);
+    return process.platform === "win32" ? parsed.pathname.replace(/^\/([A-Za-z]:)/, "$1") : parsed.pathname;
+  }
+  if (mediaUrl.startsWith("~")) {
+    return path.join(os.homedir(), mediaUrl.slice(1));
+  }
+  return path.resolve(mediaUrl);
+}
+
+/**
+ * Map a file path to the message type the WorkChat client renders as a card.
+ * The backend ChatType enum has Video/Voice/Link codes, but the open send API
+ * documents only text/image/audio — audio extensions ride "audio", everything
+ * else (images, and files outside the documented set) rides "image".
+ */
+function resolveMediaMsgType(filePath: string): "image" | "audio" {
+  const ext = path.extname(filePath).replace(/^\./, "").toLowerCase();
+  return AUDIO_EXTENSIONS.has(ext) ? "audio" : "image";
+}
+
+interface MediaSendParams {
+  account: ResolvedWorkChatAccount;
+  to: string;
+  text?: string;
+  replyToMessageId?: string;
+  conversationId?: string;
+  agentId?: string;
+}
+
+function requireAgentId(account: ResolvedWorkChatAccount, agentId?: string): string {
+  const resolved = agentId ?? account.agentId;
+  if (!resolved) {
+    throw new Error("workchat: agentId is required — complete the binding QR flow first");
+  }
+  return resolved;
+}
+
+async function sendMediaRequest(params: {
+  account: ResolvedWorkChatAccount;
+  to: string;
+  msgType: string;
+  content: string;
+  replyToMessageId?: string;
+  conversationId?: string;
+  agentId?: string;
+}): Promise<{ messageId: string }> {
+  const agentId = requireAgentId(params.account, params.agentId);
+  assertSessionActive(params.account.accountId);
+  const opts = buildApiOptions(params.account);
+  const body: {
+    agentId: string;
+    receiveId: string;
+    msgType: string;
+    content: string;
+    conversationId?: string;
+    is_last?: boolean;
+  } = {
+    agentId,
+    receiveId: params.account.userId ?? params.to,
+    msgType: params.msgType,
+    content: params.content,
+    ...(params.conversationId ? { conversationId: params.conversationId } : {}),
+  };
+  // is_last closes the streamed reply placeholder; media replies are single
+  // messages, so the media card itself is always the final frame.
+  if (params.replyToMessageId) body.is_last = true;
+  try {
+    if (params.replyToMessageId) {
+      const result = await sendWorkChatReplyMessage({ opts, messageId: params.replyToMessageId, body });
+      logger.info(`reply media sent to=${params.to} messageId=${result.msgId}`);
+      return { messageId: result.msgId };
+    }
+    const result = await sendWorkChatMessage({ opts, body });
+    logger.info(`push media sent to=${params.to} messageId=${result.msgId}`);
+    return { messageId: result.msgId };
+  } catch (err) {
+    pauseOnPermanentError(params.account.accountId, err instanceof Error ? err.message : String(err));
+    throw err;
+  }
+}
+
+/**
+ * Upload a local file and send it as a WorkChat image/audio message:
+ *   audio (wav/m4a/mp3) → msgType "audio", content {"url"}
+ *   everything else     → msgType "image", content {"url"}
+ * The media content JSON cannot carry a caption, so a text caption (when
+ * present) is sent as its own message right before the media card.
+ */
+export async function sendWorkChatMediaFile(params: MediaSendParams & {
+  filePath: string;
+}): Promise<{ messageId: string }> {
+  const { account, to, filePath } = params;
+  const opts: WorkChatApiOptions = buildApiOptions(account);
+
+  logger.info(`sendMedia: uploading filePath=${filePath} to=${to}`);
+  const uploaded = await uploadWorkChatFile({ opts, filePath, userId: account.userId ?? to });
+  logger.info(`sendMedia: upload done urlLen=${uploaded.url.length} suffix=${uploaded.suffix ?? "(none)"}`);
+
+  const caption = params.text?.trim() ?? "";
+  if (caption) {
+    await pushWorkChatMessage({
+      account,
+      to,
+      text: caption,
+      conversationId: params.conversationId,
+      agentId: params.agentId,
+    });
+  }
+
+  const msgType = resolveMediaMsgType(filePath) === "audio" ? WorkChatMsgType.Audio : WorkChatMsgType.Image;
+  return sendMediaRequest({
+    account,
+    to,
+    msgType,
+    content: JSON.stringify({ url: uploaded.url }),
+    replyToMessageId: params.replyToMessageId,
+    conversationId: params.conversationId,
+    agentId: params.agentId,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Remote URL relay
+// ---------------------------------------------------------------------------
+
+const REMOTE_MEDIA_DIR = path.join(os.tmpdir(), "openclaw", "workchat", "media");
+const REMOTE_MEDIA_DOWNLOAD_TIMEOUT_MS = 60_000;
+
+function tempMediaPath(ext: string): string {
+  return path.join(REMOTE_MEDIA_DIR, `${generateId("remote").replace(/:/g, "-")}${ext}`);
+}
+
+function extensionFromUrlOrContentType(contentType: string | null, url: string): string {
+  const fromUrl = path.extname(new URL(url).pathname).toLowerCase();
+  if (fromUrl) return fromUrl;
+  if (contentType?.startsWith("audio/mpeg")) return ".mp3";
+  if (contentType?.startsWith("audio/wav")) return ".wav";
+  if (contentType?.startsWith("audio/mp4")) return ".m4a";
+  if (contentType?.startsWith("image/")) return ".png";
+  return ".bin";
+}
+
+/**
+ * Download a remote media URL to a local temp file so the send pipeline can
+ * re-upload it to WorkChat file storage — clients render only WorkChat-hosted
+ * image/audio cards, never bare links. Bounded by a 60s abort so a hung
+ * remote never stalls the reply pipeline.
+ */
+export async function downloadRemoteMediaToTemp(url: string): Promise<string> {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), REMOTE_MEDIA_DOWNLOAD_TIMEOUT_MS);
+  let response: Response;
+  try {
+    response = (await globalThis.fetch(url, { signal: controller.signal })) as Response;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  if (!response.ok) {
+    throw new Error(
+      `remote media download failed: ${response.status} ${response.statusText} url=${url.slice(0, 80)}`,
+    );
+  }
+  const buf = Buffer.from(await response.arrayBuffer());
+  const ext = extensionFromUrlOrContentType(response.headers.get("content-type"), url);
+  await mkdir(REMOTE_MEDIA_DIR, { recursive: true });
+  const filePath = tempMediaPath(ext);
+  await writeFile(filePath, buf);
+  logger.debug(`downloadRemoteMediaToTemp: saved ${buf.length} bytes to ${filePath}`);
+  return filePath;
+}

package/src/messaging/send.ts

@@ -6,6 +6,7 @@ import {
   sendWorkChatReplyMessage,
 } from "../api/api.js";
 import type { WorkChatApiOptions } from "../api/api.js";
+import { pauseOnPermanentError } from "../api/session-guard.js";
 import type { ResolvedWorkChatAccount } from "../auth/accounts.js";
 import { logger } from "../util/logger.js";
 
@@ -38,6 +39,8 @@ function buildApiOptions(account: ResolvedWorkChatAccount): WorkChatApiOptions {
   };
 }
 
+export { buildApiOptions };
+
 /**
  * Send a reply to a specific inbound message.
  * POST /open-apis/im/v1/messages/{messageId}/reply
@@ -74,6 +77,7 @@ export async function replyWorkChatMessage(params: {
     logger.info(`reply sent to=${to} messageId=${result.msgId}`);
     return { messageId: result.msgId };
   } catch (err) {
+    pauseOnPermanentError(account.accountId, err instanceof Error ? err.message : String(err));
     logger.error(`replyWorkChatMessage: failed to=${to} err=${String(err)}`);
     throw err;
   }
@@ -113,6 +117,7 @@ export async function pushWorkChatMessage(params: {
     logger.info(`push sent to=${to} messageId=${result.msgId}`);
     return { messageId: result.msgId };
   } catch (err) {
+    pauseOnPermanentError(account.accountId, err instanceof Error ? err.message : String(err));
     logger.error(`pushWorkChatMessage: failed to=${to} err=${String(err)}`);
     throw err;
   }

package/src/storage/seen-msgids.ts

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { resolveStateDir } from "./state-dir.js";
+import { logger } from "../util/logger.js";
+
+/**
+ * Persistent inbound message-id buffer (weixin sync-buf analogue): remembers
+ * the most recently processed AGENT_MESSAGE msgIds per account so a monitor
+ * restart / platform redelivery never double-dispatches a user message.
+ */
+
+const SEEN_LIMIT = 500;
+
+function resolveSeenFilePath(accountId: string): string {
+  const safe = accountId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return path.join(resolveStateDir(), "openclaw-workchat", "accounts", `${safe}.seen-msgids.json`);
+}
+
+type SeenCache = { ids: string[]; index: Set<string> };
+const cache = new Map<string, SeenCache>();
+
+function loadSeen(accountId: string): SeenCache {
+  const cached = cache.get(accountId);
+  if (cached) return cached;
+  let ids: string[] = [];
+  try {
+    const raw = fs.readFileSync(resolveSeenFilePath(accountId), "utf-8");
+    const parsed = JSON.parse(raw) as { msgIds?: unknown };
+    if (Array.isArray(parsed.msgIds)) {
+      ids = parsed.msgIds.filter((x): x is string => typeof x === "string" && x !== "");
+    }
+  } catch {
+    // missing or corrupt file — start empty
+  }
+  const entry: SeenCache = { ids, index: new Set(ids) };
+  cache.set(accountId, entry);
+  return entry;
+}
+
+function persistSeen(accountId: string, seen: SeenCache): void {
+  try {
+    const filePath = resolveSeenFilePath(accountId);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify({ msgIds: seen.ids }), "utf-8");
+  } catch (err) {
+    logger.warn(`seen-msgids persist failed accountId=${accountId}: ${String(err)}`);
+  }
+}
+
+/** Returns true when msgId was already recorded (duplicate delivery). */
+export function isDuplicateMessage(accountId: string, msgId: string): boolean {
+  if (!msgId) return false;
+  const seen = loadSeen(accountId);
+  return seen.index.has(msgId);
+}
+
+/**
+ * Record msgId as processed. Returns true the first time (not a duplicate);
+ * false when it was already known.
+ */
+export function recordMessageProcessed(accountId: string, msgId: string): boolean {
+  if (!msgId) return true;
+  const seen = loadSeen(accountId);
+  if (seen.index.has(msgId)) return false;
+  seen.index.add(msgId);
+  seen.ids.push(msgId);
+  if (seen.ids.length > SEEN_LIMIT) {
+    const drop = seen.ids.length - SEEN_LIMIT;
+    for (const old of seen.ids.splice(0, drop)) seen.index.delete(old);
+  }
+  persistSeen(accountId, seen);
+  return true;
+}
+
+/** Clear state — only for tests. @internal */
+export function _resetSeenMsgIdsForTest(): void {
+  cache.clear();
+}