@wu529778790/open-im 1.11.1-beta.17 → 1.11.1-beta.19

package/dist/clawbot/client.d.ts

@@ -10,5 +10,5 @@
 import type { Config } from '../config.js';
 import type { ClawBotState } from './types.js';
 export declare function getChannelState(): ClawBotState;
-export declare function initClawbot(config: Config, eventHandler: (chatId: string, msgId: string, content: string) => Promise<void>, onStateChange?: (state: ClawBotState) => void): Promise<void>;
+export declare function initClawbot(config: Config, eventHandler: (chatId: string, msgId: string, content: string, imagePaths?: string[]) => Promise<void>, onStateChange?: (state: ClawBotState) => void): Promise<void>;
 export declare function stopClawbot(): void;

package/dist/clawbot/client.js

@@ -12,6 +12,7 @@ import { createLogger } from '../logger.js';
 import { jitteredDelay, isFatalReconnectError, SLOW_PROBE_MS } from '../shared/reconnect.js';
 import { cacheContextToken } from './message-sender.js';
 import { setClawbotContextToken, clearClawbotContextToken } from '../shared/active-chats.js';
+import { decryptAes256CbcMedia, saveBufferMedia, createMediaTargetPath } from '../shared/media-storage.js';
 import { CLAWBOT_POLL_INTERVAL_MS } from '../constants.js';
 const log = createLogger('ClawBot');
 const RECONNECT_DELAYS_MS = [3000, 5000, 10000, 20000, 30000];
@@ -110,6 +111,8 @@ function startPolling() {
                 }
                 // Process messages
                 const messages = res.messages ?? [];
+                // Step 1: Extract valid USER messages and cache context tokens
+                const userMessages = [];
                 for (const msg of messages) {
                     if (signal.aborted)
                         break;
@@ -120,7 +123,6 @@ function startPolling() {
                         continue;
                     const chatId = msg.from_user_id ?? '';
                     const msgId = String(msg.message_id ?? msg.seq ?? '');
-                    const content = extracted;
                     if (!chatId) {
                         log.warn('ClawBot message missing from_user_id, skipping');
                         continue;
@@ -130,10 +132,34 @@ function startPolling() {
                         cacheContextToken(chatId, msg.context_token);
                         setClawbotContextToken(msg.context_token);
                     }
-                    log.info(`ClawBot message: chatId=${chatId}, msgId=${msgId}, content="${content.substring(0, 100)}"`);
+                    // Extract and download images from message
+                    const imagePaths = await extractImages(msg);
+                    userMessages.push({ chatId, msgId, content: extracted, imagePaths: imagePaths.length > 0 ? imagePaths : undefined });
+                }
+                // Step 2: Aggregate consecutive messages from the same user
+                // ClawBot splits image+text into separate messages; combine them
+                const aggregated = [];
+                for (const m of userMessages) {
+                    const last = aggregated[aggregated.length - 1];
+                    if (last && last.chatId === m.chatId) {
+                        // Same user — merge content and image paths
+                        last.content = `${last.content}\n${m.content}`;
+                        if (m.imagePaths?.length) {
+                            last.imagePaths = [...(last.imagePaths ?? []), ...m.imagePaths];
+                        }
+                    }
+                    else {
+                        aggregated.push({ chatId: m.chatId, msgId: m.msgId, content: m.content, imagePaths: m.imagePaths });
+                    }
+                }
+                // Step 3: Dispatch aggregated messages
+                for (const m of aggregated) {
+                    if (signal.aborted)
+                        break;
+                    log.info(`ClawBot message: chatId=${m.chatId}, msgId=${m.msgId}, content="${m.content.substring(0, 100)}", images=${m.imagePaths?.length ?? 0}`);
                     if (messageHandler) {
                         try {
-                            await messageHandler(chatId, msgId, content);
+                            await messageHandler(m.chatId, m.msgId, m.content, m.imagePaths);
                         }
                         catch (err) {
                             log.error('Error in ClawBot message handler:', err);
@@ -212,6 +238,48 @@ function stopWatchdog() {
         watchdogTimer = null;
     }
 }
+/**
+ * Extract and download images from a ClawBot message's item_list.
+ * Images are encrypted with AES and hosted on CDN.
+ */
+async function extractImages(msg) {
+    if (!msg.item_list?.length)
+        return [];
+    const paths = [];
+    for (const item of msg.item_list) {
+        if (item.type !== 2 /* MessageItemType.IMAGE */)
+            continue;
+        const media = item.image_item?.media;
+        if (!media?.cdn_url)
+            continue;
+        try {
+            // Download from CDN
+            const response = await fetch(media.cdn_url, { signal: AbortSignal.timeout(30_000) });
+            if (!response.ok) {
+                log.warn(`Image download failed: HTTP ${response.status}`);
+                continue;
+            }
+            const buffer = Buffer.from(await response.arrayBuffer());
+            // Decrypt if AES key provided
+            let decrypted;
+            if (media.aes_key) {
+                decrypted = decryptAes256CbcMedia(buffer, media.aes_key);
+            }
+            else {
+                decrypted = buffer;
+            }
+            // Save to disk
+            const targetPath = createMediaTargetPath('.jpg', `clawbot-${Date.now()}`);
+            await saveBufferMedia(decrypted, targetPath);
+            paths.push(targetPath);
+            log.info(`ClawBot image saved: ${targetPath}`);
+        }
+        catch (err) {
+            log.warn('Failed to process ClawBot image:', err);
+        }
+    }
+    return paths;
+}
 /**
  * Extract text content from an iLink message's item_list.
  * Returns the first text item found, or a placeholder for media types.

package/dist/clawbot/event-handler.d.ts

@@ -7,6 +7,6 @@ export interface ClawBotEventHandlerHandle {
     stop: () => void;
     runningTasks: Map<string, import('../shared/ai-task.js').TaskRunState>;
     getRunningTaskCount: () => number;
-    handleEvent: (chatId: string, msgId: string, content: string) => Promise<void>;
+    handleEvent: (chatId: string, msgId: string, content: string, imagePaths?: string[]) => Promise<void>;
 }
 export declare function setupClawbotHandlers(config: Config, sessionManager: SessionManager): ClawBotEventHandlerHandle;

package/dist/clawbot/event-handler.js

@@ -33,8 +33,8 @@ export function setupClawbotHandlers(config, sessionManager) {
             return () => { };
         },
     };
-    async function handleEvent(chatId, msgId, content) {
-        log.info(`[handleEvent] chatId=${chatId}, msgId=${msgId}, content="${content.substring(0, 100)}"`);
+    async function handleEvent(chatId, msgId, content, imagePaths) {
+        log.info(`[handleEvent] chatId=${chatId}, msgId=${msgId}, content="${content.substring(0, 100)}", images=${imagePaths?.length ?? 0}`);
         const userId = chatId;
         const text = content.trim();
         const msgIdSender = {
@@ -61,11 +61,17 @@ export function setupClawbotHandlers(config, sessionManager) {
                 },
             }),
         });
+        // Prepend image paths to prompt so Claude can read them with its Read tool
+        let enrichedText = text;
+        if (imagePaths?.length) {
+            const imgRefs = imagePaths.map(p => `[用户发送了图片: ${p}]`).join('\n');
+            enrichedText = `${imgRefs}\n${text}`;
+        }
         await handleTextFlow({
             platform: 'clawbot',
             userId,
             chatId,
-            text,
+            text: enrichedText,
             ctx,
             handleAIRequest,
             sendTextReply: (c, t) => sendTextReply(c, t),

package/dist/config-web.js

@@ -1095,6 +1095,21 @@ export async function startWebConfigServer(options) {
             json(response, 200, { platforms, serviceStatus: getServiceStatus() }, request);
             return;
         }
+        if (request.method === "GET" && requestUrl.pathname === "/api/metrics") {
+            const file = loadFileConfig();
+            const platforms = getHealthPlatformSnapshot(file);
+            const status = getServiceStatus();
+            const uptime = process.uptime();
+            const mem = process.memoryUsage();
+            json(response, 200, {
+                uptime: Math.round(uptime),
+                memory: { rss: mem.rss, heapUsed: mem.heapUsed, heapTotal: mem.heapTotal },
+                service: { running: status.running, pid: status.pid },
+                platforms: Object.entries(platforms).map(([k, v]) => ({ name: k, configured: v.configured, enabled: v.enabled })),
+                timestamp: new Date().toISOString(),
+            }, request);
+            return;
+        }
         if (request.method === "POST" && requestUrl.pathname === "/api/service/start") {
             try {
                 const config = loadConfig();

package/dist/logger.d.ts

@@ -23,6 +23,11 @@ export declare function createLogger(tag: string): {
     debug: (msg: string, ...args: unknown[]) => void;
     infoEvent: (event: string, data?: Record<string, unknown>, msg?: string) => void;
 };
+/**
+ * Audit log — records user interactions for debugging and compliance.
+ * Always enabled, writes to audit.log.
+ */
+export declare function auditLog(platform: string, userId: string, action: string, detail?: Record<string, unknown>): void;
 export declare function emitStructuredEvent(tag: string, event: string, data?: Record<string, unknown>, level?: LogLevel, msg?: string): void;
 export declare function shutdownLoggerTelemetry(): Promise<void>;
 export declare function closeLogger(): Promise<void>;

package/dist/logger.js

@@ -12,6 +12,7 @@ let logDir = DEFAULT_LOG_DIR;
 let minLevel = LOG_LEVELS.DEBUG;
 let logStream;
 let eventsStream;
+let auditStream;
 let telemetryEnabled = false;
 let telemetryStatsTimer = null;
 let lastTelemetryStatsSignature = '';
@@ -77,6 +78,12 @@ export function initLogger(dirOrOpts, level, telemetry) {
         mkdirSync(logDir, { recursive: true });
     rotateOldLogs();
     logStream = createWriteStream(join(logDir, getLogFileName()), { flags: 'a' });
+    // Audit log — always enabled, separate file
+    if (auditStream) {
+        auditStream.end();
+        auditStream = undefined;
+    }
+    auditStream = createWriteStream(join(logDir, 'audit.log'), { flags: 'a' });
     telemetryEnabled = !!tel?.enabled;
     if (telemetryStatsTimer) {
         clearInterval(telemetryStatsTimer);
@@ -135,6 +142,20 @@ export function createLogger(tag) {
         infoEvent: (event, data, msg) => emitStructuredEvent(tag, event, data, 'INFO', msg),
     };
 }
+/**
+ * Audit log — records user interactions for debugging and compliance.
+ * Always enabled, writes to audit.log.
+ */
+export function auditLog(platform, userId, action, detail) {
+    const entry = {
+        ts: new Date().toISOString(),
+        platform,
+        userId,
+        action,
+        ...detail,
+    };
+    auditStream?.write(JSON.stringify(entry) + '\n');
+}
 export function emitStructuredEvent(tag, event, data, level = 'INFO', msg = '') {
     if (!telemetryEnabled)
         return;

package/dist/platform/handle-text-flow.js

@@ -17,7 +17,7 @@
  */
 import { setActiveChatId } from '../shared/active-chats.js';
 import { setChatUser } from '../shared/chat-user-map.js';
-import { createLogger } from '../logger.js';
+import { createLogger, auditLog } from '../logger.js';
 import { handleEnqueueResult, DEFAULT_QUEUE_FULL_MESSAGE, DEFAULT_QUEUED_MESSAGE } from '../shared/utils.js';
 const log = createLogger('TextFlow');
 /** Default access-denied message. */
@@ -79,6 +79,8 @@ export async function handleTextFlow(params) {
     if (!text) {
         return true;
     }
+    // Audit: log user interaction
+    auditLog(platform, userId, 'message', { text: text.substring(0, 200) });
     // 6. Enqueue AI request
     if (customEnqueue) {
         // Platform-specific enqueue (e.g., WorkBuddy with extra context)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.1-beta.17",
+  "version": "1.11.1-beta.19",
   "description": "Your AI coding assistant, in every chat app. Multi-platform IM bridge for Claude Code, Codex, and CodeBuddy.",
   "type": "module",
   "main": "dist/index.js",