openclaw-nim 0.0.1

package/src/media.ts

@@ -0,0 +1,315 @@
+/**
+ * NIM Media - 媒体消息处理模块 (node-nim 版本)
+ */
+
+import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { NimConfig, NimSendResult, NimMediaInfo, NimMessageEvent, NimSessionType } from "./types.js";
+import { createNimClient, getCachedNimClient } from "./client.js";
+import { normalizeNimTarget } from "./targets.js";
+import { getNimRuntime } from "./runtime.js";
+import { extname, join } from "path";
+import * as os from "os";
+import * as fs from "fs";
+import * as https from "https";
+import * as http from "http";
+
+/**
+ * 发送图片消息
+ */
+export async function sendImageNim(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  imagePath: string;
+  sessionType?: NimSessionType;
+}): Promise<NimSendResult> {
+  const { cfg, to, imagePath, sessionType = "p2p" } = params;
+  const nimCfg = cfg.channels?.nim as NimConfig;
+
+  if (!nimCfg) {
+    return { success: false, error: "NIM channel not configured" };
+  }
+
+  const targetId = normalizeNimTarget(to);
+
+  try {
+    let client = getCachedNimClient(nimCfg);
+    if (!client || !client.loggedIn) {
+      client = await createNimClient(nimCfg);
+      await client.login();
+    }
+
+    return await client.sendImage(targetId, imagePath, sessionType);
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * 发送文件消息
+ */
+export async function sendFileNim(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  filePath: string;
+  sessionType?: NimSessionType;
+}): Promise<NimSendResult> {
+  const { cfg, to, filePath, sessionType = "p2p" } = params;
+  const nimCfg = cfg.channels?.nim as NimConfig;
+
+  if (!nimCfg) {
+    return { success: false, error: "NIM channel not configured" };
+  }
+
+  const targetId = normalizeNimTarget(to);
+
+  try {
+    let client = getCachedNimClient(nimCfg);
+    if (!client || !client.loggedIn) {
+      client = await createNimClient(nimCfg);
+      await client.login();
+    }
+
+    return await client.sendFile(targetId, filePath, sessionType);
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * 发送音频消息
+ */
+export async function sendAudioNim(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  audioPath: string;
+  duration: number;
+  sessionType?: NimSessionType;
+}): Promise<NimSendResult> {
+  const { cfg, to, audioPath, duration, sessionType = "p2p" } = params;
+  const nimCfg = cfg.channels?.nim as NimConfig;
+
+  if (!nimCfg) {
+    return { success: false, error: "NIM channel not configured" };
+  }
+
+  const targetId = normalizeNimTarget(to);
+
+  try {
+    let client = getCachedNimClient(nimCfg);
+    if (!client || !client.loggedIn) {
+      client = await createNimClient(nimCfg);
+      await client.login();
+    }
+
+    return await client.sendAudio(targetId, audioPath, duration, sessionType);
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * 发送视频消息
+ */
+export async function sendVideoNim(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  videoPath: string;
+  duration: number;
+  width: number;
+  height: number;
+  sessionType?: NimSessionType;
+}): Promise<NimSendResult> {
+  const { cfg, to, videoPath, duration, width, height, sessionType = "p2p" } = params;
+  const nimCfg = cfg.channels?.nim as NimConfig;
+
+  if (!nimCfg) {
+    return { success: false, error: "NIM channel not configured" };
+  }
+
+  const targetId = normalizeNimTarget(to);
+
+  try {
+    let client = getCachedNimClient(nimCfg);
+    if (!client || !client.loggedIn) {
+      client = await createNimClient(nimCfg);
+      await client.login();
+    }
+
+    return await client.sendVideo(targetId, videoPath, duration, width, height, sessionType);
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * 下载媒体文件
+ */
+export async function downloadNimMedia(params: {
+  cfg: ClawdbotConfig;
+  url: string;
+  filename?: string;
+  maxBytes?: number;
+  log?: (msg: string) => void;
+}): Promise<NimMediaInfo | null> {
+  const { cfg, url, filename, maxBytes = 30 * 1024 * 1024, log = console.log } = params;
+
+  if (!url) {
+    return null;
+  }
+
+  try {
+    const runtime = getNimRuntime();
+    const tempDir = (runtime as any)?.tempDir || os.tmpdir();
+    
+    // 生成文件名
+    const ext = extname(url.split("?")[0]) || ".bin";
+    const name = filename || `nim_${Date.now()}${ext}`;
+    const localPath = join(tempDir, name);
+
+    // 下载文件
+    await downloadFile(url, localPath, maxBytes);
+
+    // 获取文件大小
+    const stats = fs.statSync(localPath);
+
+    // 推断媒体类型
+    const mediaType = inferMessageType(localPath);
+
+    return {
+      type: mediaType,
+      url,
+      name,
+      size: stats.size,
+      localPath,
+    };
+  } catch (error) {
+    log(`nim: failed to download media: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+}
+
+/**
+ * 从媒体信息列表构建 payload
+ */
+export function buildNimMediaPayload(mediaList: NimMediaInfo[]): Record<string, unknown> {
+  if (!mediaList || mediaList.length === 0) {
+    return {};
+  }
+
+  return {
+    MediaAttachments: mediaList.map((m) => ({
+      type: m.type,
+      url: m.url,
+      name: m.name,
+      size: m.size,
+      localPath: m.localPath,
+    })),
+  };
+}
+
+/**
+ * 推断消息的媒体类型占位符（用于 AI 显示）
+ */
+export function inferMediaPlaceholder(messageType: string): string {
+  switch (messageType) {
+    case "image":
+      return "[图片]";
+    case "audio":
+      return "[语音消息]";
+    case "video":
+      return "[视频]";
+    case "file":
+      return "[文件]";
+    case "geo":
+    case "location":
+      return "[位置]";
+    default:
+      return "[多媒体消息]";
+  }
+}
+
+/**
+ * 根据文件扩展名推断消息类型
+ */
+export function inferMessageType(filePath: string): "image" | "file" | "audio" | "video" {
+  const ext = extname(filePath).toLowerCase();
+  
+  const imageExts = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"];
+  const audioExts = [".mp3", ".wav", ".aac", ".m4a", ".ogg", ".amr"];
+  const videoExts = [".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv"];
+
+  if (imageExts.includes(ext)) return "image";
+  if (audioExts.includes(ext)) return "audio";
+  if (videoExts.includes(ext)) return "video";
+  return "file";
+}
+
+/**
+ * 辅助函数：下载文件
+ */
+function downloadFile(url: string, destPath: string, maxBytes: number = 30 * 1024 * 1024): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith("https") ? https : http;
+    const file = fs.createWriteStream(destPath);
+    let downloadedBytes = 0;
+
+    protocol.get(url, (response) => {
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        // 处理重定向
+        const redirectUrl = response.headers.location;
+        if (redirectUrl) {
+          file.close();
+          try { fs.unlinkSync(destPath); } catch {}
+          downloadFile(redirectUrl, destPath, maxBytes).then(resolve).catch(reject);
+          return;
+        }
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        try { fs.unlinkSync(destPath); } catch {}
+        reject(new Error(`Download failed with status ${response.statusCode}`));
+        return;
+      }
+
+      response.on("data", (chunk) => {
+        downloadedBytes += chunk.length;
+        if (downloadedBytes > maxBytes) {
+          response.destroy();
+          file.close();
+          try { fs.unlinkSync(destPath); } catch {}
+          reject(new Error(`File too large (>${maxBytes} bytes)`));
+        }
+      });
+
+      response.pipe(file);
+
+      file.on("finish", () => {
+        file.close();
+        resolve();
+      });
+
+      file.on("error", (err) => {
+        file.close();
+        try { fs.unlinkSync(destPath); } catch {}
+        reject(err);
+      });
+    }).on("error", (err) => {
+      file.close();
+      try { fs.unlinkSync(destPath); } catch {}
+      reject(err);
+    });
+  });
+}

package/src/monitor.ts

@@ -0,0 +1,196 @@
+/**
+ * NIM Monitor - 消息监听模块 (node-nim 版本)
+ */
+
+import type { ClawdbotConfig, RuntimeEnv } from "clawdbot/plugin-sdk";
+import type { NimConfig, NimClientInstance, NimMessageEvent } from "./types.js";
+import { createNimClient, clearNimClientCache } from "./client.js";
+import { resolveNimCredentials } from "./accounts.js";
+import { handleNimMessage } from "./bot.js";
+
+/** 监控状态 */
+interface MonitorState {
+  client: NimClientInstance;
+  running: boolean;
+  abortController: AbortController;
+}
+
+/** 监控状态缓存 */
+const monitorStates = new Map<string, MonitorState>();
+
+/**
+ * 启动 NIM 消息监听
+ */
+export async function monitorNimProvider(params: {
+  cfg: ClawdbotConfig;
+  runtime: RuntimeEnv;
+  abortSignal?: AbortSignal;
+}): Promise<void> {
+  const { cfg, runtime, abortSignal } = params;
+  const nimCfg = cfg.channels?.nim as NimConfig;
+
+  if (!nimCfg) {
+    console.error("[NIM] Channel not configured");
+    return;
+  }
+
+  const creds = resolveNimCredentials(nimCfg);
+  if (!creds) {
+    console.error("[NIM] Credentials not configured");
+    return;
+  }
+  const monitorKey = `${creds.appKey}:${creds.account}`;
+
+  // 检查是否已有监控在运行
+  if (monitorStates.has(monitorKey)) {
+    console.log("[NIM] Monitor already running for", creds.account);
+    return;
+  }
+
+  console.log("[NIM] Starting monitor for account:", creds.account);
+
+  try {
+    // 创建客户端并登录
+    const client = await createNimClient(nimCfg);
+    const loginSuccess = await client.login();
+
+    if (!loginSuccess) {
+      console.error("[NIM] Login failed, cannot start monitor");
+      return;
+    }
+
+    console.log("[NIM] Login successful, starting message listener");
+
+    // 创建 AbortController 用于停止监控
+    const abortController = new AbortController();
+
+    // 保存监控状态
+    const state: MonitorState = {
+      client,
+      running: true,
+      abortController,
+    };
+    monitorStates.set(monitorKey, state);
+
+    // 注册消息处理回调
+    const messageHandler = async (msg: NimMessageEvent) => {
+      if (!state.running) return;
+
+      // 忽略自己发送的消息
+      if (msg.from === creds.account) {
+        return;
+      }
+
+      console.log("[NIM] Received message from:", msg.from, "type:", msg.type);
+
+      try {
+        await handleNimMessage({
+          cfg,
+          runtime,
+          message: msg,
+        });
+      } catch (error) {
+        console.error("[NIM] Error handling message:", error);
+      }
+    };
+
+    client.onMessage(messageHandler);
+
+    // 注册连接状态回调
+    client.onConnectionChange((status) => {
+      console.log("[NIM] Connection status changed:", status);
+
+      if (status === "kickout") {
+        console.warn("[NIM] Account kicked out, stopping monitor");
+        stopNimMonitor(nimCfg);
+      } else if (status === "disconnected") {
+        console.warn("[NIM] Disconnected, will try to reconnect");
+        // SDK 会自动重连
+      }
+    });
+
+    // 监听外部中止信号
+    if (abortSignal) {
+      abortSignal.addEventListener("abort", () => {
+        console.log("[NIM] Received abort signal, stopping monitor");
+        stopNimMonitor(nimCfg);
+      });
+    }
+
+    // 监听内部中止信号
+    abortController.signal.addEventListener("abort", () => {
+      state.running = false;
+      client.offMessage(messageHandler);
+    });
+
+    console.log("[NIM] Monitor started successfully");
+  } catch (error) {
+    console.error("[NIM] Failed to start monitor:", error);
+    throw error;
+  }
+}
+
+/**
+ * 停止 NIM 消息监听
+ */
+export async function stopNimMonitor(cfg: NimConfig): Promise<void> {
+  const creds = resolveNimCredentials(cfg);
+  if (!creds) {
+    console.log("[NIM] No credentials to stop monitor");
+    return;
+  }
+  const monitorKey = `${creds.appKey}:${creds.account}`;
+
+  const state = monitorStates.get(monitorKey);
+  if (!state) {
+    console.log("[NIM] No monitor running for", creds.account);
+    return;
+  }
+
+  console.log("[NIM] Stopping monitor for account:", creds.account);
+
+  state.running = false;
+  state.abortController.abort();
+
+  try {
+    await state.client.logout();
+  } catch (error) {
+    console.error("[NIM] Error during logout:", error);
+  }
+
+  monitorStates.delete(monitorKey);
+  console.log("[NIM] Monitor stopped");
+}
+
+/**
+ * 检查监控是否在运行
+ */
+export function isNimMonitorRunning(cfg: NimConfig): boolean {
+  const creds = resolveNimCredentials(cfg);
+  if (!creds) return false;
+  const monitorKey = `${creds.appKey}:${creds.account}`;
+  const state = monitorStates.get(monitorKey);
+  return state?.running ?? false;
+}
+
+/**
+ * 停止所有监控
+ */
+export async function stopAllNimMonitors(): Promise<void> {
+  console.log("[NIM] Stopping all monitors...");
+  
+  for (const [key, state] of monitorStates.entries()) {
+    state.running = false;
+    state.abortController.abort();
+    try {
+      await state.client.logout();
+    } catch (error) {
+      console.error("[NIM] Error stopping monitor:", key, error);
+    }
+  }
+
+  monitorStates.clear();
+  await clearNimClientCache();
+  
+  console.log("[NIM] All monitors stopped");
+}