@wu529778790/open-im 1.6.1 → 1.6.2

package/dist/codex/cli-runner.d.ts

@@ -31,4 +31,6 @@ export interface CodexRunOptions {
 export interface CodexRunHandle {
     abort: () => void;
 }
+export declare function extractPromptImagePaths(prompt: string): string[];
+export declare function buildCodexArgs(prompt: string, sessionId: string | undefined, workDir: string, options?: CodexRunOptions): string[];
 export declare function runCodex(cliPath: string, prompt: string, sessionId: string | undefined, workDir: string, callbacks: CodexRunCallbacks, options?: CodexRunOptions): CodexRunHandle;

package/dist/codex/cli-runner.js

@@ -2,7 +2,7 @@
  * Codex CLI runner for `codex exec --json` JSONL output.
  */
 import { execFileSync, spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { createLogger } from '../logger.js';
@@ -10,6 +10,17 @@ const log = createLogger('CodexCli');
 const windowsCodexLaunchCache = new Map();
 const MAX_TIMEOUT_MS = 2_147_483_647;
 const DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+const SUPPORTED_IMAGE_EXTENSIONS = new Set([
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.webp',
+    '.bmp',
+    '.tif',
+    '.tiff',
+    '.avif',
+]);
 function getIdleTimeoutMs(totalTimeoutMs) {
     const raw = process.env.CODEX_IDLE_TIMEOUT_MS;
     const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
@@ -31,11 +42,42 @@ function parseCodexEvent(line) {
         return null;
     }
 }
-function buildCodexArgs(_prompt, sessionId, workDir, options) {
+function isSupportedImagePath(filePath) {
+    const normalized = filePath.trim();
+    if (!normalized || !existsSync(normalized))
+        return false;
+    const lower = normalized.toLowerCase();
+    return Array.from(SUPPORTED_IMAGE_EXTENSIONS).some((ext) => lower.endsWith(ext));
+}
+export function extractPromptImagePaths(prompt) {
+    const imagePaths = new Set();
+    const lines = prompt.split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const singleMatch = /^Saved local file path:\s*(.+)$/i.exec(line);
+        if (singleMatch) {
+            const candidate = singleMatch[1].trim();
+            if (isSupportedImagePath(candidate))
+                imagePaths.add(candidate);
+            continue;
+        }
+        const batchMatch = /^\d+\.\s+(?:.+:\s+)?(.+?)\s+\((image)\)$/i.exec(line);
+        if (batchMatch) {
+            const candidate = batchMatch[1].trim();
+            if (isSupportedImagePath(candidate))
+                imagePaths.add(candidate);
+        }
+    }
+    return Array.from(imagePaths);
+}
+export function buildCodexArgs(prompt, sessionId, workDir, options) {
     const commonOptions = ['--json', '--skip-git-repo-check'];
     const newSessionOptions = [...commonOptions, '--cd', workDir];
     const resumeOptions = [...commonOptions];
     const canResume = Boolean(sessionId) && options?.permissionMode !== 'plan';
+    const imagePaths = extractPromptImagePaths(prompt);
     if (options?.skipPermissions) {
         newSessionOptions.push('--dangerously-bypass-approvals-and-sandbox');
         resumeOptions.push('--dangerously-bypass-approvals-and-sandbox');
@@ -51,6 +93,10 @@ function buildCodexArgs(_prompt, sessionId, workDir, options) {
         newSessionOptions.push('--model', options.model);
         resumeOptions.push('--model', options.model);
     }
+    for (const imagePath of imagePaths) {
+        newSessionOptions.push('--image', imagePath);
+        resumeOptions.push('--image', imagePath);
+    }
     if (sessionId && !canResume) {
         log.warn('Codex plan mode does not support resume; starting a new read-only session');
     }

package/dist/codex/cli-runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/codex/cli-runner.test.js

@@ -0,0 +1,53 @@
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { afterEach, describe, expect, it } from 'vitest';
+import { buildCodexArgs, extractPromptImagePaths } from './cli-runner.js';
+const tempDirs = [];
+function createTempImage(name) {
+    const dir = mkdtempSync(join(tmpdir(), 'open-im-codex-test-'));
+    tempDirs.push(dir);
+    const path = join(dir, name);
+    writeFileSync(path, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+    return path;
+}
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('extractPromptImagePaths', () => {
+    it('extracts a single saved image path from a media prompt', () => {
+        const imagePath = createTempImage('single.png');
+        const prompt = [
+            'The user sent a DingTalk image message.',
+            `Saved local file path: ${imagePath}`,
+            'Use the Read tool to inspect the saved file and describe the relevant visual contents before answering.',
+        ].join('\n\n');
+        expect(extractPromptImagePaths(prompt)).toEqual([imagePath]);
+    });
+    it('extracts image items from batch media prompts and ignores non-images', () => {
+        const imagePath = createTempImage('batch.png');
+        const prompt = [
+            'Saved local file paths:',
+            `1. photo: ${imagePath} (image)`,
+            '2. notes.txt (file)',
+        ].join('\n');
+        expect(extractPromptImagePaths(prompt)).toEqual([imagePath]);
+    });
+});
+describe('buildCodexArgs', () => {
+    it('adds image attachments for new sessions', () => {
+        const imagePath = createTempImage('new-session.png');
+        const args = buildCodexArgs(`Saved local file path: ${imagePath}`, undefined, 'D:\\coding\\open-im', {});
+        expect(args).toContain('--image');
+        expect(args).toContain(imagePath);
+    });
+    it('adds image attachments for resumed sessions', () => {
+        const imagePath = createTempImage('resume-session.png');
+        const args = buildCodexArgs(`Saved local file path: ${imagePath}`, 'session-123', 'D:\\coding\\open-im', {});
+        expect(args.slice(0, 2)).toEqual(['exec', 'resume']);
+        expect(args).toContain('--image');
+        expect(args).toContain(imagePath);
+    });
+});

package/dist/dingtalk/client.d.ts

@@ -8,9 +8,15 @@ export interface DingTalkStreamingTarget {
     senderId?: string;
     robotCode?: string;
 }
+export interface DingTalkDownloadedMessageFile {
+    buffer: Buffer;
+    contentType?: string;
+    filename?: string;
+}
 export declare function shouldSuppressDingTalkSocketWarn(args: unknown[]): boolean;
 export declare function registerSessionWebhook(chatId: string, sessionWebhook: string): void;
 export declare function sendText(chatId: string, content: string): Promise<unknown>;
+export declare function downloadRobotMessageFile(downloadCode: string, robotCode: string): Promise<DingTalkDownloadedMessageFile>;
 export declare function sendMarkdown(chatId: string, title: string, text: string): Promise<unknown>;
 export declare function ackMessage(messageId: string, result?: unknown): void;
 export declare function initDingTalk(cfg: Config, eventHandler: (data: DWClientDownStream) => Promise<void>): Promise<void>;

package/dist/dingtalk/client.js

@@ -78,6 +78,68 @@ export async function sendText(chatId, content) {
         text: { content },
     });
 }
+export async function downloadRobotMessageFile(downloadCode, robotCode) {
+    const accessToken = await getClient().getAccessToken();
+    const response = await fetch(`${DINGTALK_OPENAPI_BASE}/v1.0/robot/messageFiles/download`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            'x-acs-dingtalk-access-token': String(accessToken),
+        },
+        body: JSON.stringify({ downloadCode, robotCode }),
+        signal: AbortSignal.timeout(30000),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`DingTalk message file download failed: ${response.status} ${text}`);
+    }
+    const contentType = response.headers.get('content-type') ?? undefined;
+    const contentDisposition = response.headers.get('content-disposition') ?? '';
+    const filenameMatch = /filename\*=UTF-8''([^;]+)|filename="?([^\";]+)"?/i.exec(contentDisposition);
+    const filename = filenameMatch?.[1] ?? filenameMatch?.[2];
+    const buffer = Buffer.from(await response.arrayBuffer());
+    if (contentType?.includes('application/json')) {
+        let parsed;
+        try {
+            parsed = JSON.parse(buffer.toString('utf8'));
+        }
+        catch {
+            throw new Error(`DingTalk message file download returned JSON payload that could not be parsed`);
+        }
+        const errorCode = parsed.code ?? parsed.errcode ?? parsed.errorcode;
+        if (errorCode !== undefined && errorCode !== 0 && errorCode !== '0') {
+            const message = typeof parsed.message === 'string'
+                ? parsed.message
+                : typeof parsed.errmsg === 'string'
+                    ? parsed.errmsg
+                    : JSON.stringify(parsed);
+            throw new Error(`DingTalk message file download business error: ${String(errorCode)} ${message}`);
+        }
+        const downloadUrl = typeof parsed.downloadUrl === 'string'
+            ? parsed.downloadUrl
+            : typeof parsed.download_url === 'string'
+                ? parsed.download_url
+                : typeof parsed.url === 'string'
+                    ? parsed.url
+                    : undefined;
+        if (!downloadUrl) {
+            throw new Error(`DingTalk message file download returned JSON without binary payload or download URL`);
+        }
+        const redirected = await fetch(downloadUrl, {
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!redirected.ok) {
+            const text = await redirected.text();
+            throw new Error(`DingTalk redirected file download failed: ${redirected.status} ${text}`);
+        }
+        return {
+            buffer: Buffer.from(await redirected.arrayBuffer()),
+            contentType: redirected.headers.get('content-type') ?? undefined,
+            filename,
+        };
+    }
+    return { buffer, contentType, filename };
+}
 export async function sendMarkdown(chatId, title, text) {
     return sendByWebhook(chatId, {
         msgtype: 'markdown',

package/dist/dingtalk/event-handler.js

@@ -1,7 +1,7 @@
 import { AccessControl } from '../access/access-control.js';
 import { RequestQueue } from '../queue/request-queue.js';
 import { configureDingTalkMessageSender, sendThinkingMessage, updateMessage, sendFinalMessages, sendErrorMessage, sendTextReply, sendImageReply, startTypingLoop, sendPermissionCard, sendModeCard, sendDirectorySelection, } from './message-sender.js';
-import { ackMessage, registerSessionWebhook } from './client.js';
+import { ackMessage, downloadRobotMessageFile, registerSessionWebhook } from './client.js';
 import { registerPermissionSender } from '../hook/permission-server.js';
 import { CommandHandler } from '../commands/handler.js';
 import { getAdapter } from '../adapters/registry.js';
@@ -14,7 +14,7 @@ import { buildUnsupportedInboundMessage } from '../channels/capabilities.js';
 import { buildMediaMetadataPrompt } from '../shared/media-prompt.js';
 import { buildSavedMediaPrompt } from '../shared/media-analysis-prompt.js';
 import { buildMediaContext } from '../shared/media-context.js';
-import { downloadMediaFromUrl } from '../shared/media-storage.js';
+import { downloadMediaFromUrl, inferExtensionFromBuffer, inferExtensionFromContentType, saveBufferMedia, } from '../shared/media-storage.js';
 const log = createLogger('DingTalkHandler');
 const DINGTALK_THROTTLE_MS = 1000;
 function parseRobotMessage(data) {
@@ -73,7 +73,7 @@ function buildDingTalkMediaContext(text, payload) {
         Duration: duration,
     }, text);
 }
-async function buildMediaPrompt(message, kind) {
+async function buildMediaPrompt(message, kind, robotCodeFallback) {
     const payload = extractMediaPayload(message, kind);
     if (!payload)
         return null;
@@ -85,6 +85,12 @@ async function buildMediaPrompt(message, kind) {
         payload.download_url,
         payload.picUrl,
     ].find((value) => typeof value === 'string' && value.length > 0);
+    const downloadCode = [
+        payload.downloadCode,
+        payload.download_code,
+        payload.pictureDownloadCode,
+        payload.picture_download_code,
+    ].find((value) => typeof value === 'string' && value.length > 0);
     let localPath;
     if (remoteUrl) {
         try {
@@ -97,6 +103,25 @@ async function buildMediaPrompt(message, kind) {
             localPath = undefined;
         }
     }
+    if (!localPath && downloadCode) {
+        try {
+            const robotCode = (typeof message.robotCode === 'string' && message.robotCode.length > 0
+                ? message.robotCode
+                : robotCodeFallback) ?? '';
+            if (robotCode) {
+                const downloaded = await downloadRobotMessageFile(downloadCode, robotCode);
+                const extension = inferExtensionFromContentType(downloaded.contentType ?? '') ||
+                    inferExtensionFromBuffer(downloaded.buffer) ||
+                    (kind === 'image' ? '.jpg' : '.bin');
+                const basenameHint = downloaded.filename ??
+                    (typeof payload.fileName === 'string' ? payload.fileName : undefined);
+                localPath = await saveBufferMedia(downloaded.buffer, extension, basenameHint);
+            }
+        }
+        catch {
+            localPath = undefined;
+        }
+    }
     if (localPath) {
         return buildSavedMediaPrompt({
             source: 'DingTalk',
@@ -221,7 +246,7 @@ export function setupDingTalkHandlers(config, sessionManager) {
         };
         if (message.msgtype !== 'text') {
             const kind = toInboundKind(message.msgtype);
-            const prompt = await buildMediaPrompt(message, kind);
+            const prompt = await buildMediaPrompt(message, kind, config.dingtalkClientId);
             if (!prompt) {
                 await sendTextReply(chatId, buildUnsupportedInboundMessage('dingtalk', kind));
                 ackMessage(callbackId, { ignored: message.msgtype });

package/package.json

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