@qihoo/tuitui-openclaw-channel 2026.3.1-3.13

package/src/types.ts

@@ -0,0 +1,123 @@
+/**
+ * Shared TypeScript types for the TuiTui channel plugin.
+ */
+
+export interface TuiTuiInboundMessage {
+  cid: string;
+  uid: string;
+  user_account: string;
+  user_name: string;
+  timestamp: string;
+  event: 'single_chat' | 'group_chat';
+  data: TuiTuiMessageData;
+}
+
+export interface TuiTuiMessageData {
+  msgid: string;
+  msg_type: 'text' | 'image' | 'mixed' | 'voice' | 'file';
+  text?: string;
+  images?: string[];
+  image_ids?: string[];
+  voice?: string;
+  voice_id?: string;
+  file?: { name: string; url: string; file_id: string };
+  // Group chat fields
+  group_id?: string;
+  group_name?: string;
+  at_me?: boolean;
+  at?: Array<{ is_at_all: boolean; cid?: string; uid?: string; name?: string }>;
+  // Reference/reply fields
+  ref?: {
+    cid: string;
+    uid: string;
+    user_account?: string;
+    user_name: string;
+    is_me?: boolean;
+    msgid: string;
+    msg_type: 'text' | 'image' | 'mixed' | 'file' | 'voice';
+    text?: string;
+    images?: string[];
+    image_ids?: string[];
+  };
+}
+
+export interface TuiTuiOutboundTextMessage {
+  tousers: string[];
+  togroups: string[];
+  at: string[];
+  msgtype: 'text';
+  text: { content: string; reference_msgid?: string };
+}
+
+export interface TuiTuiOutboundLinkMessage {
+  tousers: string[];
+  togroups: string[];
+  msgtype: 'link';
+  link: {
+    url: string;
+    title: string;
+    content?: string;
+    image?: string;
+  };
+}
+
+export interface TuiTuiOutboundImageMessage {
+  tousers?: string[];
+  togroups?: string[];
+  at?: string;
+  msgtype: 'image';
+  image: { media_id: string };
+}
+
+export interface TuiTuiOutboundAttachmentMessage {
+  tousers?: string[];
+  togroups?: string[];
+  at?: string;
+  msgtype: 'attachment';
+  attachment: { media_id: string };
+}
+
+export interface TuiTuiOutboundPageMessage {
+  tousers: string[];
+  togroups: string[];
+  msgtype: 'page';
+  page: {
+    title: string;
+    summary?: string;
+    content: string;
+    image?: string;
+    format?: 'html';
+    privilege?: 'specific' | 'scope' | 'corp' | 'any';
+    delims_left?: string;
+    delims_right?: string;
+    kv?: Record<string, string>;
+    default_value?: string;
+    debug?: boolean;
+  };
+}
+
+export type TuiTuiOutboundMessage =
+  | TuiTuiOutboundTextMessage
+  | TuiTuiOutboundLinkMessage
+  | TuiTuiOutboundImageMessage
+  | TuiTuiOutboundAttachmentMessage
+  | TuiTuiOutboundPageMessage;
+
+export interface TuiTuiMediaUploadResponse {
+  errcode: number;
+  errmsg: string;
+  filename?: string;
+  media_id?: string;
+}
+
+
+
+export interface TuiTuiSingleEmojiReactionTarget {
+  user?: string;
+  msgid?: string;
+}
+
+export interface TuiTuiGroupEmojiReactionTarget {
+  group?: string;
+  msgid?: string;
+}

package/src/utils.ts

@@ -0,0 +1,344 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import type { IncomingMessage } from 'node:http';
+import { basename } from 'node:path';
+import { fetchWithSsrFGuard } from 'openclaw/plugin-sdk';
+import type { TuiTuiMessageData, TuiTuiMediaUploadResponse, TuiTuiSingleEmojiReactionTarget, TuiTuiGroupEmojiReactionTarget } from './types';
+
+/* 一些常量配置 */
+export const CHANNEL_ID = 'tuitui';
+export const CHANNEL_NAME = 'TuiTui';
+export const TUITUI_SSRF_POLICY = { allowedHostnames: ['im.live.360.cn'] } as const;
+
+export function addParams2Url(urlStr: string, params: any) {
+  const url = new URL(urlStr);
+  for (let k in params) url.searchParams.set(k, params[k]);
+  return url.toString();
+}
+
+/** Detect media type from filename or content type. */
+export function detectMediaType(filename: string, contentType?: string): 'image' | 'file' {
+  return /^image\//i.test(contentType) || /\.(jpg|jpeg|png|gif|webp|bmp|svg)$/i.test(filename) ? 'image' : 'file';
+}
+
+export function getExt(filename: string) : string {
+  const fns = filename.split('.');
+  return fns.length > 1 ? fns[fns.length - 1].toLowerCase() : '';
+}
+
+const mimeTypes: Record<string, string> = {
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  png: 'image/png',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  bmp: 'image/bmp',
+  svg: 'image/svg+xml',
+  pdf: 'application/pdf',
+  txt: 'text/plain',
+  json: 'application/json',
+  mp3: 'audio/mpeg',
+  mp4: 'video/mp4',
+};
+/** Get MIME type from file extension. */
+export function getMimeType(filename: string): string {
+  return mimeTypes[getExt(filename)] || 'application/octet-stream';
+}
+
+function _fetch(opts: any): Promise<any> {
+  return fetchWithSsrFGuard({
+    //url: mediaSrc,
+    policy: TUITUI_SSRF_POLICY,
+    //auditContext: "tuitui.media.download",
+    ...opts,
+  })
+}
+function _fetchJson(url: string, json: any, auditContext: string): Promise<any> {
+  return _fetch({
+    url,
+    init: {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(json),
+    },
+    auditContext,
+  });
+}
+export async function postTuituiMsg(account: any, json: any, auditContext: string, log: any): Promise<any> {
+  const { appId: appid, appSecret: secret } = account;
+  const { response, release } = await _fetchJson(
+    addParams2Url('https://im.live.360.cn:8282/robot/message/custom/send', { appid, secret }),
+    json,
+    auditContext,
+  );
+  try {
+    const bodyText = await response.text();
+    let parsed: any = null;
+    try {
+      parsed = bodyText ? JSON.parse(bodyText) : null;
+    } catch(err) {
+      parsed = null;
+    }
+
+    log?.debug?.(
+      `[${CHANNEL_ID}] ${auditContext} response status=${response.status} ok=${response.ok} body=${bodyText || '<empty>'}`,
+    );
+
+    if (!response.ok) {
+      throw new Error(
+        `[${CHANNEL_ID}] ${auditContext} Failed: ${response.status} ${response.statusText}; body=${bodyText || '<empty>'}`,
+      );
+    }
+
+    if (parsed && typeof parsed.errcode === 'number' && parsed.errcode !== 0) {
+      throw new Error(
+        `[${CHANNEL_ID}] ${auditContext} Failed: errcode=${parsed.errcode} errmsg=${parsed.errmsg ?? 'Unknown error'}`,
+      );
+    }
+  } finally {
+    await release();
+  }
+}
+
+/**
+ * Upload media to TuiTui and get media_id.
+ * Supports:
+ * - HTTP/HTTPS URLs (downloads then uploads)
+ * - Local file paths (reads then uploads)
+ * - Base64 data URLs (decodes then uploads)
+ *
+ * @param mediaSrc - The URL, file path, or data URL of the media
+ * @param appid - TuiTui app ID
+ * @param secret - TuiTui app secret
+ * @param type - Media type: 'image' or "file" (auto-detected if not specified)
+ * @returns The media_id from TuiTui
+ */
+export async function uploadMediaToTuiTui(mediaSrc: string, appid: string, secret: string, type?: 'image' | 'file'): Promise<string> {
+  let mediaBuffer: ArrayBuffer;
+  let contentType: string;
+  let filename: string;
+
+  // Check if it's a Base64 data URL
+  if (/^data\:/.test(mediaSrc)) {
+    const matches = mediaSrc.match(/^data:([^;,]*)(;base64)?,(.*)$/);
+    if (!matches) {
+      throw new Error(`[${CHANNEL_ID}] Invalid data URL format`);
+    }
+
+    contentType = matches[1] || "application/octet-stream";
+    const isBase64 = !!matches[2];
+    const data = matches[3];
+
+    if (isBase64) {
+      // Use atob if available; fallback to Buffer for Node environments
+      let binaryString: string;
+      if (typeof atob === "function") {
+        binaryString = atob(data);
+      } else {
+        binaryString = Buffer.from(data, "base64").toString("binary");
+      }
+      const bytes = new Uint8Array(binaryString.length);
+      for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+      }
+      mediaBuffer = bytes.buffer;
+    } else {
+      mediaBuffer = new TextEncoder().encode(decodeURIComponent(data)).buffer;
+    }
+
+    const ext = contentType.split("/")[1] || "bin";
+    filename = `media_${Date.now()}.${ext}`;
+  }
+  // HTTP/HTTPS URL
+  else if (/^https?\:/.test(mediaSrc)) {
+    const { response, release } = await _fetch({
+      url: mediaSrc,
+      auditContext: 'tuitui.media.download',
+    });
+    try {
+      if (!response.ok) {
+        throw new Error(`[${CHANNEL_ID}] Failed to download media from ${mediaSrc}: ${response.status}`);
+      }
+
+      mediaBuffer = await response.arrayBuffer();
+      contentType = response.headers.get("content-type") || "application/octet-stream";
+
+      filename = "media";
+      const urlPath = new URL(mediaSrc).pathname;
+      const pathParts = urlPath.split("/");
+      if (pathParts.length > 0 && pathParts[pathParts.length - 1]) {
+        filename = pathParts[pathParts.length - 1];
+      }
+      const contentDisposition = response.headers.get("content-disposition");
+      if (contentDisposition) {
+        const match = contentDisposition.match(/filename\*?=(?:UTF-8''|")?([^";\r\n]+)"?/i);
+        if (match) {
+          filename = decodeURIComponent(match[1]);
+        }
+      }
+    } finally {
+      await release();
+    }
+  }
+  // Check if it's a local file path
+  else {
+    if (!existsSync(mediaSrc)) {
+      throw new Error(`[${CHANNEL_ID}] Local file not found: ${mediaSrc}`);
+    }
+
+    const stats = statSync(mediaSrc);
+    const maxSize = 10 * 1024 * 1024;
+    if (stats.size > maxSize) {
+      throw new Error(
+        `[${CHANNEL_ID}] File too large: ${mediaSrc} (${(stats.size / 1024 / 1024).toFixed(2)}MB > 10MB limit)`,
+      );
+    }
+
+    const fileBuffer = readFileSync(mediaSrc);
+    mediaBuffer = fileBuffer.buffer.slice(
+      fileBuffer.byteOffset,
+      fileBuffer.byteOffset + fileBuffer.byteLength,
+    );
+
+    filename = basename(mediaSrc);
+    contentType = getMimeType(filename);
+  }
+
+  const _type = type || detectMediaType(filename, contentType); // Auto-detect type if not specified
+  const uploadUrl = addParams2Url('https://im.live.360.cn:8282/robot/media/upload', { appid, secret, type: _type });
+
+  const formData = new FormData();
+  formData.append("media", new Blob([mediaBuffer], { type: contentType }), filename);
+
+  const { response, release } = await _fetch({
+    url: uploadUrl,
+    init: {
+      method: "POST",
+      body: formData,
+    },
+    auditContext: "tuitui.media.upload",
+  });
+  try {
+    if (!response.ok) {
+      throw new Error(`[${CHANNEL_ID}] Failed to upload media to TuiTui: ${response.status}`);
+    }
+
+    const result: TuiTuiMediaUploadResponse = await response.json();
+
+    if (result.errcode !== 0 || !result.media_id) {
+      throw new Error(`[${CHANNEL_ID}] TuiTui media upload failed: ${result.errmsg || "Unknown error"}`);
+    }
+
+    return result.media_id;
+  } finally {
+    await release();
+  }
+}
+
+/**
+ * Build message body text from TuiTui inbound message data.
+ * Handles text, image, voice, file, and reference messages.
+ */
+export function buildMessageBody(data: TuiTuiMessageData): string {
+  const parts: string[] = [];
+
+  switch (data.msg_type) {
+    case "text":
+      if (data.text?.trim()) {
+        parts.push(data.text.trim());
+      }
+      break;
+
+    case "mixed":
+      if (data.text?.trim()) {
+        parts.push(data.text.trim());
+      }
+      if (data.images && data.images.length > 0) {
+        if (data.images.length === 1) {
+          parts.push(`[图片] ${data.images[0]}`);
+        } else {
+          parts.push(`[图片] 共 ${data.images.length} 张图片:`);
+          data.images.forEach((url, i) => parts.push(`  ${i + 1}. ${url}`));
+        }
+      }
+      break;
+
+    case "image":
+      if (data.images && data.images.length > 0) {
+        if (data.images.length === 1) {
+          parts.push(`[图片] ${data.images[0]}`);
+        } else {
+          parts.push(`[图片] 共 ${data.images.length} 张图片:`);
+          data.images.forEach((url, i) => parts.push(`  ${i + 1}. ${url}`));
+        }
+      }
+      break;
+
+    case "voice":
+      if (data.voice) {
+        parts.push(`[语音] ${data.voice}`);
+      }
+      break;
+
+    case "file":
+      if (data.file) {
+        parts.push(`[文件] ${data.file.name}: ${data.file.url}`);
+      }
+      break;
+  }
+
+  // Handle reference/reply
+  if (data.ref && data.ref.is_me) {
+    const refPrefix = `[引用机器人消息]`;
+    let refContent = "";
+    switch (data.ref.msg_type) {
+      case "text":
+        refContent = data.ref.text || "";
+        break;
+      case "image":
+        refContent = data.ref.images?.length ? `[图片]` : "[图片]";
+        break;
+      default:
+        refContent = `[${data.ref.msg_type}]`;
+    }
+    parts.unshift(`${refPrefix}\n> ${refContent}`);
+  }
+
+  return parts.join("\n");
+}
+
+export async function tuituiEmojiReaction(
+  appid:string,
+  secret: string,
+  target: string,
+  targetIsGroup: boolean,
+  msgid: string,
+  emoji: string
+): Promise<string> {
+
+  const payload = {
+    msgtype: "emoji_reaction",
+    tousers:[] as TuiTuiSingleEmojiReactionTarget[],
+    togroups:[] as TuiTuiGroupEmojiReactionTarget[],
+    emoji_reaction: { emoji: emoji, cancel: false},
+  };
+  if(targetIsGroup) {
+    payload.togroups.push({group: target, msgid: msgid});
+  } else {
+    payload.tousers.push({user: target, msgid: msgid});
+  }
+
+  const sendUrl = addParams2Url('https://im.live.360.cn:8282/robot/message/custom/modify', { appid, secret });
+  const { response, release } = await _fetchJson(sendUrl, payload, 'tuitui.emoji_reaction');
+
+  try {
+    const body = await response.text().catch(() => "");
+    //console.log('Response body:', body)
+  } catch (error) {
+    console.error('Caught exception:', error)
+  } finally {
+    await release();
+  }
+
+  return '';
+}