@wu529778790/open-im 1.6.1-beta.2 → 1.6.1-beta.3

package/dist/shared/media-storage.d.ts

@@ -1,5 +1,8 @@
 export declare function inferExtensionFromContentType(contentType: string): string;
+export declare function inferExtensionFromBuffer(buffer: Buffer): string;
 export declare function createMediaTargetPath(extension: string, basenameHint?: string): string;
+export declare function saveBufferMedia(buffer: Buffer, extension: string, basenameHint?: string): Promise<string>;
+export declare function decryptAes256CbcMedia(buffer: Buffer, aesKey: string): Buffer;
 export declare function saveBase64Media(base64: string, extension: string, basenameHint?: string): Promise<string>;
 export declare function downloadMediaFromUrl(url: string, options?: {
     basenameHint?: string;

package/dist/shared/media-storage.js

@@ -1,3 +1,4 @@
+import { createDecipheriv } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { extname, join } from "node:path";
 import { IMAGE_DIR } from "../constants.js";
@@ -22,6 +23,30 @@ export function inferExtensionFromContentType(contentType) {
         return ".json";
     return "";
 }
+export function inferExtensionFromBuffer(buffer) {
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff)
+        return ".jpg";
+    if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return ".png";
+    if (buffer.length >= 6) {
+        const gifHeader = buffer.subarray(0, 6).toString("ascii");
+        if (gifHeader === "GIF87a" || gifHeader === "GIF89a")
+            return ".gif";
+    }
+    if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP")
+        return ".webp";
+    if (buffer.length >= 2 && buffer.subarray(0, 2).toString("ascii") === "BM")
+        return ".bmp";
+    if (buffer.length >= 4 && (buffer.subarray(0, 4).toString("ascii") === "II*\0" || buffer.subarray(0, 4).toString("ascii") === "MM\0*"))
+        return ".tif";
+    if (buffer.length >= 4 && buffer.subarray(0, 4).toString("ascii") === "%PDF")
+        return ".pdf";
+    if (buffer.length >= 4 && buffer.subarray(0, 4).toString("ascii") === "OggS")
+        return ".ogg";
+    if (buffer.length >= 12 && buffer.subarray(4, 8).toString("ascii") === "ftyp")
+        return ".mp4";
+    return "";
+}
 export function createMediaTargetPath(extension, basenameHint) {
     const safeExtension = extension.startsWith(".") ? extension : `.${extension}`;
     const safeBasename = basenameHint ? sanitizeName(basenameHint) : `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
@@ -29,12 +54,32 @@ export function createMediaTargetPath(extension, basenameHint) {
     const filename = existingExtension ? safeBasename : `${safeBasename}${safeExtension}`;
     return join(IMAGE_DIR, filename);
 }
-export async function saveBase64Media(base64, extension, basenameHint) {
+export async function saveBufferMedia(buffer, extension, basenameHint) {
     await mkdir(IMAGE_DIR, { recursive: true });
     const path = createMediaTargetPath(extension, basenameHint);
-    await writeFile(path, Buffer.from(base64, "base64"));
+    await writeFile(path, buffer);
     return path;
 }
+function decodeAesKey(aesKey) {
+    const normalized = aesKey.trim().replace(/\s+/g, "").replace(/-/g, "+").replace(/_/g, "/");
+    const withPadding = normalized.length % 4 === 0 ? normalized : normalized.padEnd(normalized.length + (4 - (normalized.length % 4)), "=");
+    const decoded = Buffer.from(withPadding, "base64");
+    if (decoded.length === 32)
+        return decoded;
+    const utf8 = Buffer.from(aesKey, "utf8");
+    if (utf8.length === 32)
+        return utf8;
+    throw new Error(`Invalid AES key length: expected 32 bytes, got ${decoded.length || utf8.length}`);
+}
+export function decryptAes256CbcMedia(buffer, aesKey) {
+    const key = decodeAesKey(aesKey);
+    const iv = key.subarray(0, 16);
+    const decipher = createDecipheriv("aes-256-cbc", key, iv);
+    return Buffer.concat([decipher.update(buffer), decipher.final()]);
+}
+export async function saveBase64Media(base64, extension, basenameHint) {
+    return saveBufferMedia(Buffer.from(base64, "base64"), extension, basenameHint);
+}
 export async function downloadMediaFromUrl(url, options) {
     await mkdir(IMAGE_DIR, { recursive: true });
     const response = await fetch(url, { signal: AbortSignal.timeout(30000) });

package/dist/shared/media-storage.test.js

@@ -1,5 +1,6 @@
+import { createCipheriv, randomBytes } from "node:crypto";
 import { describe, expect, it } from "vitest";
-import { createMediaTargetPath, inferExtensionFromContentType } from "./media-storage.js";
+import { createMediaTargetPath, decryptAes256CbcMedia, inferExtensionFromBuffer, inferExtensionFromContentType, } from "./media-storage.js";
 describe("createMediaTargetPath", () => {
     it("does not append a fallback extension when basename already has one", () => {
         const path = createMediaTargetPath("bin", "report.pdf");
@@ -19,3 +20,20 @@ describe("inferExtensionFromContentType", () => {
         expect(inferExtensionFromContentType("application/pdf")).toBe(".pdf");
     });
 });
+describe("inferExtensionFromBuffer", () => {
+    it("detects jpeg files from the magic header", () => {
+        const buffer = Buffer.from([0xff, 0xd8, 0xff, 0xdb, 0x00, 0x43]);
+        expect(inferExtensionFromBuffer(buffer)).toBe(".jpg");
+    });
+});
+describe("decryptAes256CbcMedia", () => {
+    it("decrypts WeWork-style AES-256-CBC media buffers", () => {
+        const key = randomBytes(32);
+        const iv = key.subarray(0, 16);
+        const plaintext = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0x00, 0x10, 0x4a, 0x46, 0x49, 0x46]);
+        const cipher = createCipheriv("aes-256-cbc", key, iv);
+        const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        const aesKey = key.toString("base64").replace(/=+$/g, "");
+        expect(decryptAes256CbcMedia(encrypted, aesKey)).toEqual(plaintext);
+    });
+});

package/dist/wework/event-handler.js

@@ -15,7 +15,7 @@ import { setChatUser } from '../shared/chat-user-map.js';
 import { createLogger } from '../logger.js';
 import { buildUnsupportedInboundMessage } from '../channels/capabilities.js';
 import { buildMediaMetadataPrompt } from '../shared/media-prompt.js';
-import { downloadMediaFromUrl, saveBase64Media } from '../shared/media-storage.js';
+import { decryptAes256CbcMedia, downloadMediaFromUrl, inferExtensionFromBuffer, inferExtensionFromContentType, saveBase64Media, saveBufferMedia, } from '../shared/media-storage.js';
 import { buildSavedMediaPrompt } from '../shared/media-analysis-prompt.js';
 import { buildMediaContext } from '../shared/media-context.js';
 const log = createLogger('WeWorkHandler');
@@ -87,10 +87,26 @@ async function buildMediaPrompt(data, kind) {
         }
         else if (typeof imagePayload.url === 'string' && imagePayload.url.length > 0) {
             try {
-                const savedPath = await downloadMediaFromUrl(imagePayload.url, {
-                    basenameHint: imagePayload.md5,
-                    fallbackExtension: 'jpg',
-                });
+                let savedPath = '';
+                if (typeof imagePayload.aeskey === 'string' && imagePayload.aeskey.trim().length > 0) {
+                    const response = await fetch(imagePayload.url, { signal: AbortSignal.timeout(30000) });
+                    if (!response.ok) {
+                        throw new Error(`Failed to download media: HTTP ${response.status}`);
+                    }
+                    const encryptedBuffer = Buffer.from(await response.arrayBuffer());
+                    const decryptedBuffer = decryptAes256CbcMedia(encryptedBuffer, imagePayload.aeskey);
+                    const extension = inferExtensionFromBuffer(decryptedBuffer) ||
+                        inferExtensionFromContentType(response.headers.get('content-type') ?? '') ||
+                        '.jpg';
+                    savedPath = await saveBufferMedia(decryptedBuffer, extension, imagePayload.md5);
+                    log.info(`Downloaded and decrypted WeWork image: ${savedPath}`);
+                }
+                else {
+                    savedPath = await downloadMediaFromUrl(imagePayload.url, {
+                        basenameHint: imagePayload.md5,
+                        fallbackExtension: 'jpg',
+                    });
+                }
                 return buildSavedMediaPrompt({
                     source: 'WeWork',
                     kind: 'image',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.6.1-beta.2",
+  "version": "1.6.1-beta.3",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, Cursor)",
   "type": "module",
   "main": "dist/index.js",