palz-connector 1.1.0 → 1.1.1

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "palz-connector",
   "name": "Palz Connector Channel",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Palz IM 接入 OpenClaw",
   "channels": [
     "palz-connector"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palz-connector",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "type": "module",
   "main": "index.ts",
   "description": "Palz IM 接入 OpenClaw — 模块化架构，基于 OpenClaw Runtime 消息管道",
@@ -16,6 +16,7 @@
     }
   },
   "dependencies": {
+    "ali-oss": "^6.21.0",
     "ws": "^8.18.0"
   }
 }

package/src/media.ts

@@ -1,7 +1,7 @@
 /**
  * Palz Connector 媒体处理
  *
- * 将 IM 消息中的 base64 图片提取并保存到临时文件，
+ * 将 IM 消息中的图片上传到 OSS，返回公网 URL，
  * 供 OpenClaw Runtime 作为媒体附件处理。
  */
 
@@ -9,80 +9,45 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import type { OpenAIContent, ContentPart, ImageUrlContentPart, PalzMediaInfo } from "./types.js";
+import { uploadFileToOss, uploadBufferToOss } from "./oss.js";
 
-function mimeToExt(mime: string): string {
-  const map: Record<string, string> = {
-    "image/jpeg": ".jpg",
-    "image/png": ".png",
-    "image/gif": ".gif",
-    "image/webp": ".webp",
-    "image/bmp": ".bmp",
-  };
-  return map[mime] || ".png";
-}
-
-/**
- * 从 base64 data URL 提取图片并保存到临时文件。
- */
-async function saveDataUrlToTempFile(
-  dataUrl: string,
-  log?: (...args: any[]) => void,
-): Promise<PalzMediaInfo | null> {
-  const match = dataUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
-  if (!match) {
-    log?.(`palz-media: [saveDataUrl] 不匹配 data URL 格式, url前60字符="${dataUrl.slice(0, 60)}"`);
-    return null;
-  }
-
-  const mimeType = match[1];
-  const base64Data = match[2];
-  const ext = mimeToExt(mimeType);
-  const tmpDir = path.join(os.tmpdir(), "palz-media");
-  fs.mkdirSync(tmpDir, { recursive: true });
-  const filePath = path.join(tmpDir, `palz_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`);
-
-  try {
-    const buf = Buffer.from(base64Data, "base64");
-    fs.writeFileSync(filePath, buf);
-    log?.(`palz-media: [saveDataUrl] 输入: mime=${mimeType} base64Len=${base64Data.length} → 输出: path=${filePath} fileSize=${buf.length}bytes`);
-    return { path: filePath, contentType: mimeType, placeholder: "<media:image>" };
-  } catch (err: any) {
-    log?.(`palz-media: [saveDataUrl] 失败: mime=${mimeType} error=${err.message}`);
-    return null;
-  }
-}
+/** OpenClaw 允许访问的媒体目录 */
+const MEDIA_DIR = path.join(os.homedir(), ".openclaw", "media");
 
 /**
- * 从 HTTP URL 下载图片并保存到临时文件。
+ * 将 Buffer 保存到 OpenClaw 媒体目录，返回 PalzMediaInfo。
  */
-async function downloadToTempFile(
-  url: string,
+function saveBufferToMediaDir(
+  buffer: Buffer,
+  contentType: string,
+  ext: string,
   log?: (...args: any[]) => void,
-): Promise<PalzMediaInfo | null> {
-  log?.(`palz-media: [download] 输入: url=${url.slice(0, 200)}`);
+): PalzMediaInfo | null {
   try {
-    const resp = await fetch(url);
-    if (!resp.ok) {
-      log?.(`palz-media: [download] 失败: status=${resp.status} url=${url.slice(0, 200)}`);
-      return null;
-    }
-    const contentType = resp.headers.get("content-type")?.split(";")[0]?.trim() || "image/png";
-    const buffer = Buffer.from(await resp.arrayBuffer());
-    const ext = mimeToExt(contentType);
-    const tmpDir = path.join(os.tmpdir(), "palz-media");
-    fs.mkdirSync(tmpDir, { recursive: true });
-    const filePath = path.join(tmpDir, `palz_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`);
+    fs.mkdirSync(MEDIA_DIR, { recursive: true });
+    const filePath = path.join(MEDIA_DIR, `palz_${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`);
     fs.writeFileSync(filePath, buffer);
-    log?.(`palz-media: [download] 输出: path=${filePath} contentType=${contentType} fileSize=${buffer.length}bytes`);
+    log?.(`palz-media: [saveToMediaDir] 成功: path=${filePath} size=${buffer.length}bytes mime=${contentType}`);
     return { path: filePath, contentType, placeholder: "<media:image>" };
   } catch (err: any) {
-    log?.(`palz-media: [download] 异常: url=${url.slice(0, 200)} error=${err.message}`);
+    log?.(`palz-media: [saveToMediaDir] 失败: error=${err.message}`);
     return null;
   }
 }
 
+function mimeToExt(mime: string): string {
+  const map: Record<string, string> = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/bmp": ".bmp",
+  };
+  return map[mime] || ".png";
+}
+
 /**
- * 从 OpenAI Content 中提取所有图片，保存到临时文件。
+ * 从 OpenAI Content 中提取所有图片，上传到 OSS 并返回公网 URL。
  */
 export async function resolvePalzMediaList(
   content: OpenAIContent,
@@ -106,9 +71,30 @@ export async function resolvePalzMediaList(
     let info: PalzMediaInfo | null = null;
 
     if (url.startsWith("data:")) {
-      info = await saveDataUrlToTempFile(url, log);
+      // data URL → 解码 → 保存到 OpenClaw 媒体目录
+      const match = url.match(/^data:(image\/[^;]+);base64,(.+)$/);
+      if (match) {
+        const mimeType = match[1];
+        const base64Data = match[2];
+        const ext = mimeToExt(mimeType);
+        const buffer = Buffer.from(base64Data, "base64");
+        info = saveBufferToMediaDir(buffer, mimeType, ext, log);
+      }
     } else if (url.startsWith("http://") || url.startsWith("https://")) {
-      info = await downloadToTempFile(url, log);
+      // HTTP URL → 下载 → 保存到 OpenClaw 媒体目录
+      try {
+        const resp = await fetch(url);
+        if (resp.ok) {
+          const contentType = resp.headers.get("content-type")?.split(";")[0]?.trim() || "image/png";
+          const buffer = Buffer.from(await resp.arrayBuffer());
+          const ext = mimeToExt(contentType);
+          info = saveBufferToMediaDir(buffer, contentType, ext, log);
+        } else {
+          log?.(`palz-media: [resolve] HTTP下载失败: status=${resp.status}`);
+        }
+      } catch (err: any) {
+        log?.(`palz-media: [resolve] HTTP下载异常: ${err.message}`);
+      }
     }
 
     if (info) {
@@ -124,59 +110,76 @@ export async function resolvePalzMediaList(
 }
 
 /**
- * 将本地文件路径或 HTTP URL 转为 data URL（用于出站消息）。
+ * 将本地文件路径、data URL 或 HTTP URL 转为 OSS 公网链接（用于出站消息）。
+ * 替代 loadMediaAsDataUrl，避免 base64 传输。
  */
-export async function loadMediaAsDataUrl(
+export async function loadMediaAsOssUrl(
   mediaUrl: string,
   log?: (...args: any[]) => void,
 ): Promise<string | null> {
-  log?.(`palz-media: [loadAsDataUrl] 输入: url=${mediaUrl.slice(0, 200)}`);
+  log?.(`palz-media: [loadAsOssUrl] 输入: url=${mediaUrl.slice(0, 200)}`);
 
-  if (mediaUrl.startsWith("data:")) {
-    log?.(`palz-media: [loadAsDataUrl] 已是data URL, 直接返回`);
+  // 已经是 OSS 链接，直接返回
+  if (mediaUrl.startsWith("https://oss.csaiagent.com/") || mediaUrl.startsWith("https://cstv-data.oss-cn-beijing.aliyuncs.com/")) {
+    log?.(`palz-media: [loadAsOssUrl] 已是OSS链接, 直接返回`);
     return mediaUrl;
   }
 
-  const filePath = mediaUrl.replace(/^MEDIA:/, "");
-  if (filePath.startsWith("/")) {
+  // data URL → 解码 → 上传到 OSS
+  if (mediaUrl.startsWith("data:")) {
+    const match = mediaUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
+    if (!match) {
+      log?.(`palz-media: [loadAsOssUrl] data URL 格式不匹配`);
+      return null;
+    }
+    const mimeType = match[1];
+    const base64Data = match[2];
+    const ext = mimeToExt(mimeType);
+    try {
+      const buffer = Buffer.from(base64Data, "base64");
+      const ossUrl = await uploadBufferToOss(buffer, ext, log);
+      log?.(`palz-media: [loadAsOssUrl] data URL → OSS: mime=${mimeType} bufSize=${buffer.length} ossUrl=${ossUrl}`);
+      return ossUrl;
+    } catch (err: any) {
+      log?.(`palz-media: [loadAsOssUrl] data URL上传OSS失败: ${err.message}`);
+      return null;
+    }
+  }
+
+  // 本地文件路径（绝对或相对）→ 上传到 OSS
+  const rawPath = mediaUrl.replace(/^MEDIA:/, "");
+  const filePath = path.isAbsolute(rawPath) ? rawPath : path.resolve(rawPath);
+  if (fs.existsSync(filePath)) {
     try {
-      const buffer = fs.readFileSync(filePath);
-      const ext = path.extname(filePath).toLowerCase();
-      const mimeMap: Record<string, string> = {
-        ".jpg": "image/jpeg",
-        ".jpeg": "image/jpeg",
-        ".png": "image/png",
-        ".gif": "image/gif",
-        ".webp": "image/webp",
-      };
-      const mimeType = mimeMap[ext] || "image/png";
-      const dataUrl = `data:${mimeType};base64,${buffer.toString("base64")}`;
-      log?.(`palz-media: [loadAsDataUrl] 输出: 本地文件=${filePath} size=${buffer.length}bytes mime=${mimeType} dataUrlLen=${dataUrl.length}`);
-      return dataUrl;
+      const ossUrl = await uploadFileToOss(filePath, log);
+      log?.(`palz-media: [loadAsOssUrl] 本地文件 → OSS: path=${filePath} ossUrl=${ossUrl}`);
+      return ossUrl;
     } catch (err: any) {
-      log?.(`palz-media: [loadAsDataUrl] 读取本地文件失败: ${filePath} error=${err.message}`);
+      log?.(`palz-media: [loadAsOssUrl] 本地文件上传OSS失败: ${filePath} error=${err.message}`);
       return null;
     }
   }
 
+  // HTTP URL → 下载 → 上传到 OSS
   if (mediaUrl.startsWith("http://") || mediaUrl.startsWith("https://")) {
     try {
       const resp = await fetch(mediaUrl);
       if (!resp.ok) {
-        log?.(`palz-media: [loadAsDataUrl] HTTP下载失败: status=${resp.status}`);
+        log?.(`palz-media: [loadAsOssUrl] HTTP下载失败: status=${resp.status}`);
         return null;
       }
-      const mimeType = resp.headers.get("content-type")?.split(";")[0]?.trim() || "image/png";
+      const contentType = resp.headers.get("content-type")?.split(";")[0]?.trim() || "image/png";
       const buffer = Buffer.from(await resp.arrayBuffer());
-      const dataUrl = `data:${mimeType};base64,${buffer.toString("base64")}`;
-      log?.(`palz-media: [loadAsDataUrl] 输出: HTTP url下载完成 size=${buffer.length}bytes mime=${mimeType} dataUrlLen=${dataUrl.length}`);
-      return dataUrl;
+      const ext = mimeToExt(contentType);
+      const ossUrl = await uploadBufferToOss(buffer, ext, log);
+      log?.(`palz-media: [loadAsOssUrl] HTTP → OSS: size=${buffer.length} mime=${contentType} ossUrl=${ossUrl}`);
+      return ossUrl;
     } catch (err: any) {
-      log?.(`palz-media: [loadAsDataUrl] HTTP下载异常: url=${mediaUrl.slice(0, 200)} error=${err.message}`);
+      log?.(`palz-media: [loadAsOssUrl] HTTP下载上传OSS异常: ${err.message}`);
       return null;
     }
   }
 
-  log?.(`palz-media: [loadAsDataUrl] 无法识别的URL格式`);
+  log?.(`palz-media: [loadAsOssUrl] 无法识别的URL格式`);
   return null;
 }

package/src/oss.ts

@@ -0,0 +1,91 @@
+/**
+ * Palz Connector OSS 工具
+ *
+ * 阿里云 OSS 上传/下载，AK/SK 通过环境变量读取：
+ *   OSS_ACCESS_KEY_ID
+ *   OSS_ACCESS_KEY_SECRET
+ *
+ * 上传后返回公网可访问的 URL。
+ */
+
+import OSS from "ali-oss";
+import path from "path";
+import fs from "fs";
+
+const OSS_REGION = "oss-cn-beijing";
+const OSS_BUCKET = "cstv-data";
+const OSS_CUSTOM_DOMAIN = "oss.csaiagent.com";
+const OSS_UPLOAD_PREFIX = "palz-media";
+
+let _client: OSS | null = null;
+
+function getOssClient(): OSS {
+  if (_client) return _client;
+
+  const accessKeyId = process.env.OSS_ACCESS_KEY_ID;
+  const accessKeySecret = process.env.OSS_ACCESS_KEY_SECRET;
+
+  if (!accessKeyId || !accessKeySecret) {
+    throw new Error(
+      "OSS credentials not configured. Set OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables.",
+    );
+  }
+
+  _client = new OSS({
+    region: OSS_REGION,
+    accessKeyId,
+    accessKeySecret,
+    bucket: OSS_BUCKET,
+  });
+
+  return _client;
+}
+
+/**
+ * 上传本地文件到 OSS，返回公网 URL。
+ */
+export async function uploadFileToOss(
+  localPath: string,
+  log?: (...args: any[]) => void,
+): Promise<string | null> {
+  log?.(`palz-oss: [upload] 输入: localPath=${localPath}`);
+  try {
+    const client = getOssClient();
+    const ext = path.extname(localPath) || ".png";
+    const objectName = `${OSS_UPLOAD_PREFIX}/${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
+
+    const fileBuffer = fs.readFileSync(localPath);
+    await client.put(objectName, fileBuffer);
+
+    const fileUrl = `https://${OSS_CUSTOM_DOMAIN}/${objectName}`;
+    log?.(`palz-oss: [upload] 成功: objectName=${objectName} url=${fileUrl}`);
+    return fileUrl;
+  } catch (err: any) {
+    log?.(`palz-oss: [upload] 失败: localPath=${localPath} error=${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * 上传 Buffer 到 OSS，返回公网 URL。
+ */
+export async function uploadBufferToOss(
+  buffer: Buffer,
+  ext: string = ".png",
+  log?: (...args: any[]) => void,
+): Promise<string | null> {
+  log?.(`palz-oss: [uploadBuffer] 输入: bufferSize=${buffer.length} ext=${ext}`);
+  try {
+    const client = getOssClient();
+    const objectName = `${OSS_UPLOAD_PREFIX}/${Date.now()}_${Math.random().toString(36).slice(2, 8)}${ext}`;
+
+    await client.put(objectName, buffer);
+
+    const fileUrl = `https://${OSS_CUSTOM_DOMAIN}/${objectName}`;
+    log?.(`palz-oss: [uploadBuffer] 成功: objectName=${objectName} url=${fileUrl}`);
+    return fileUrl;
+  } catch (err: any) {
+    log?.(`palz-oss: [uploadBuffer] 失败: error=${err.message}`);
+    return null;
+  }
+}

package/src/outbound.ts

@@ -7,7 +7,7 @@
 
 import { resolvePalzAccount } from "./config.js";
 import { sendToPalzIM } from "./send.js";
-import { loadMediaAsDataUrl } from "./media.js";
+import { loadMediaAsOssUrl } from "./media.js";
 import { parsePalzTarget } from "./targets.js";
 import type { ContentPart, TextContentPart, OpenAIContent } from "./types.js";
 
@@ -51,10 +51,10 @@ export const palzOutbound = {
     }
 
     if (mediaUrl) {
-      const dataUrl = await loadMediaAsDataUrl(mediaUrl, log);
-      if (dataUrl) {
-        contentParts.push({ type: "image_url", image_url: { url: dataUrl } });
-        log(`palz-outbound: [sendMedia] 媒体转换成功: dataUrlLen=${dataUrl.length}`);
+      const ossUrl = await loadMediaAsOssUrl(mediaUrl, log);
+      if (ossUrl) {
+        contentParts.push({ type: "image_url", image_url: { url: ossUrl } });
+        log(`palz-outbound: [sendMedia] 媒体转换成功: ossUrl=${ossUrl}`);
       } else {
         contentParts.push({ type: "text", text: `\n📎 ${mediaUrl}` });
         log(`palz-outbound: [sendMedia] 媒体转换失败, 使用文本链接替代`);

package/src/reply-dispatcher.ts

@@ -9,7 +9,7 @@
  */
 
 import { getPalzRuntime } from "./runtime.js";
-import { loadMediaAsDataUrl } from "./media.js";
+import { loadMediaAsOssUrl } from "./media.js";
 import { sendToPalzIM } from "./send.js";
 import type { PalzConfig, StreamChunkOpts, ContentPart, OpenAIContent } from "./types.js";
 
@@ -119,10 +119,10 @@ export function createPalzReplyDispatcher(params: CreatePalzReplyDispatcherParam
 
         for (let i = 0; i < mediaUrls.length; i++) {
           log(`${tag}: [DELIVER 媒体] ${i + 1}/${mediaUrls.length} url=${mediaUrls[i].slice(0, 200)}`);
-          const dataUrl = await loadMediaAsDataUrl(mediaUrls[i], log);
-          if (dataUrl) {
-            contentParts.push({ type: "image_url", image_url: { url: dataUrl } });
-            log(`${tag}: [DELIVER 媒体转换成功] ${i + 1}/${mediaUrls.length} dataUrlLen=${dataUrl.length}`);
+          const ossUrl = await loadMediaAsOssUrl(mediaUrls[i], log);
+          if (ossUrl) {
+            contentParts.push({ type: "image_url", image_url: { url: ossUrl } });
+            log(`${tag}: [DELIVER 媒体转换成功] ${i + 1}/${mediaUrls.length} ossUrl=${ossUrl}`);
           } else {
             contentParts.push({ type: "text", text: `\n📎 ${mediaUrls[i]}` });
             log(`${tag}: [DELIVER 媒体转换失败] ${i + 1}/${mediaUrls.length} 使用文本链接替代`);