ylib-syim 0.0.31 → 0.0.33

package/bridges/main.ts

@@ -6909,6 +6909,7 @@ function readEffectiveWhitelistFromConfig(
         "modelName",
         "agentId",
         "asyncMode",
+        "injectSenderContextToPrompt",
         "gatewayPort",
         "gatewayBaseUrl",
         "uploadHost",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ylib-syim",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "description": "多 IM / 多 Agent 的会话路由与上下文管理（支持 /new）",
   "type": "module",
   "exports": {
@@ -46,9 +46,9 @@
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "ylib-dingtalk-connector": "0.7.10-beta.18",
-    "ylib-openclaw-lark": "2026.3.17-beta.23",
-    "ylib-openclaw-weixin": "2.1.7-beta.11",
+    "ylib-dingtalk-connector": "0.7.10-beta.20",
+    "ylib-openclaw-lark": "2026.3.17-beta.24",
+    "ylib-openclaw-weixin": "2.1.7-beta.12",
     "axios": "^1.6.0",
     "dingtalk-stream": "^2.1.4",
     "fluent-ffmpeg": "^2.1.3",

package/scripts/weixin-stdio-bridge.ts

@@ -1,10 +1,168 @@
 import fs from "node:fs";
+import fsPromises from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import crypto from "node:crypto";
+import { fileTypeFromBuffer } from "file-type";
 
 const CHANNEL_KEY = "openclaw-weixin";
 let bridgeDefaultAccountAlias = "weixin-single";
 const bridgeAliasLogMemo = new Set<string>();
+const MEDIA_FILE_MODE = 0o644;
+const DEFAULT_MEDIA_MAX_BYTES = 5 * 1024 * 1024;
+const EXT_BY_MIME: Record<string, string> = {
+  "image/heic": ".heic",
+  "image/heif": ".heif",
+  "image/jpeg": ".jpg",
+  "image/png": ".png",
+  "image/webp": ".webp",
+  "image/gif": ".gif",
+  "audio/ogg": ".ogg",
+  "audio/mpeg": ".mp3",
+  "audio/x-m4a": ".m4a",
+  "audio/mp4": ".m4a",
+  "video/mp4": ".mp4",
+  "video/quicktime": ".mov",
+  "application/pdf": ".pdf",
+  "application/json": ".json",
+  "application/zip": ".zip",
+  "application/gzip": ".gz",
+  "application/x-tar": ".tar",
+  "application/x-7z-compressed": ".7z",
+  "application/vnd.rar": ".rar",
+  "application/msword": ".doc",
+  "application/vnd.ms-excel": ".xls",
+  "application/vnd.ms-powerpoint": ".ppt",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+    ".docx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation":
+    ".pptx",
+  "text/csv": ".csv",
+  "text/plain": ".txt",
+  "text/markdown": ".md",
+};
+const MIME_BY_EXT: Record<string, string> = {
+  ...Object.fromEntries(Object.entries(EXT_BY_MIME).map(([mime, ext]) => [ext, mime])),
+  ".jpeg": "image/jpeg",
+  ".js": "text/javascript",
+};
+
+function sanitizeFilename(name: string): string {
+  const trimmed = name.trim();
+  if (!trimmed) return "";
+  const sanitized = trimmed.replace(/[^\p{L}\p{N}._-]+/gu, "_");
+  return sanitized.replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 60);
+}
+
+function normalizeMimeType(mime?: string | null): string | undefined {
+  if (!mime) return undefined;
+  const cleaned = mime.split(";")[0]?.trim().toLowerCase();
+  return cleaned || undefined;
+}
+
+function extensionForMime(mime?: string | null): string | undefined {
+  const normalized = normalizeMimeType(mime);
+  if (!normalized) return undefined;
+  return EXT_BY_MIME[normalized];
+}
+
+function getFileExtension(filePath?: string | null): string | undefined {
+  if (!filePath) return undefined;
+  try {
+    if (/^https?:\/\//i.test(filePath)) {
+      const url = new URL(filePath);
+      return path.extname(url.pathname).toLowerCase() || undefined;
+    }
+  } catch {
+    // fall back
+  }
+  const ext = path.extname(filePath).toLowerCase();
+  return ext || undefined;
+}
+
+function isGenericMime(mime?: string): boolean {
+  if (!mime) return true;
+  const lower = mime.toLowerCase();
+  return lower === "application/octet-stream" || lower === "application/zip";
+}
+
+function isMissingPathError(err: unknown): err is NodeJS.ErrnoException {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+
+async function retryAfterRecreatingDir<T>(
+  dir: string,
+  run: () => Promise<T>,
+): Promise<T> {
+  try {
+    return await run();
+  } catch (err) {
+    if (!isMissingPathError(err)) throw err;
+    await fsPromises.mkdir(dir, { recursive: true, mode: 0o700 });
+    return await run();
+  }
+}
+
+async function detectMime(opts: {
+  buffer?: Buffer;
+  headerMime?: string | null;
+  filePath?: string;
+}): Promise<string | undefined> {
+  const ext = getFileExtension(opts.filePath);
+  const extMime = ext ? MIME_BY_EXT[ext] : undefined;
+  const headerMime = normalizeMimeType(opts.headerMime);
+  let sniffed: string | undefined;
+  if (opts.buffer) {
+    try {
+      const fileType = await fileTypeFromBuffer(opts.buffer);
+      sniffed = fileType?.mime ?? undefined;
+    } catch {
+      sniffed = undefined;
+    }
+  }
+  if (sniffed && (!isGenericMime(sniffed) || !extMime)) return sniffed;
+  if (extMime) return extMime;
+  if (headerMime && !isGenericMime(headerMime)) return headerMime;
+  if (sniffed) return sniffed;
+  if (headerMime) return headerMime;
+  return undefined;
+}
+
+async function saveMediaBufferFromOpenclaw(
+  buffer: Buffer,
+  contentType?: string,
+  subdir = "inbound",
+  maxBytes = DEFAULT_MEDIA_MAX_BYTES,
+  originalFilename?: string,
+): Promise<{ id: string; path: string; size: number; contentType?: string }> {
+  if (buffer.byteLength > maxBytes) {
+    throw new Error(
+      `Media exceeds ${(maxBytes / (1024 * 1024)).toFixed(0)}MB limit`,
+    );
+  }
+  const dir = path.join(os.tmpdir(), "openclaw-media", subdir);
+  await fsPromises.mkdir(dir, { recursive: true, mode: 0o700 });
+  const uuid = crypto.randomUUID();
+  const headerExt = extensionForMime(contentType?.split(";")[0]?.trim());
+  const mime = await detectMime({ buffer, headerMime: contentType });
+  const ext = headerExt ?? extensionForMime(mime) ?? "";
+
+  let id: string;
+  if (originalFilename) {
+    const base = path.parse(originalFilename).name;
+    const sanitized = sanitizeFilename(base);
+    id = sanitized ? `${sanitized}---${uuid}${ext}` : `${uuid}${ext}`;
+  } else {
+    id = ext ? `${uuid}${ext}` : uuid;
+  }
+
+  const dest = path.join(dir, id);
+  await retryAfterRecreatingDir(dir, () =>
+    fsPromises.writeFile(dest, buffer, { mode: MEDIA_FILE_MODE }),
+  );
+  return { id, path: dest, size: buffer.byteLength, contentType: mime };
+}
 
 function logBridgeAlias(from: string, to: string, reason: string): void {
   const key = `${from}->${to}:${reason}`;
@@ -503,6 +661,9 @@ function buildMinimalRuntime(
       activity: {
         record: () => {},
       },
+      media: {
+        saveMediaBuffer: saveMediaBufferFromOpenclaw,
+      },
     },
     system: {
       enqueueSystemEvent: () => {},