@kafca/agentdock 0.1.20 → 0.1.22

package/dist-electron/services/local-ai-core/src/{gateway → channel/weixin}/local-core-weixin-gateway.js

@@ -9,7 +9,8 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_events_1 = require("node:events");
 const node_crypto_2 = require("node:crypto");
-const desktop_js_1 = require("../../../../shared/desktop.js");
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const file_utils_js_1 = require("../shared/file-utils.js");
 // ==================== Constants ====================
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 const DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
@@ -33,6 +34,8 @@ const TEXT_ITEM_TYPE = 1;
 const IMAGE_ITEM_TYPE = 2;
 const VOICE_ITEM_TYPE = 3;
 const FILE_ITEM_TYPE = 4;
+const UPLOAD_MEDIA_TYPE_FILE = 3;
+const WEIXIN_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 // ==================== Utilities ====================
 function stripHtml(html) {
     let result = html;
@@ -453,6 +456,76 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return '';
         }
     }
+    async sendOutboundMessage(workspaceId, input) {
+        const state = this.runtime.get(workspaceId);
+        if (!state?.connected) {
+            throw new Error(`WeChat workspace is not connected: ${workspaceId}`);
+        }
+        const channelId = String(input.route?.channelId || '').trim();
+        if (!channelId) {
+            throw new Error('Missing WeChat target channel id');
+        }
+        const binding = await this.getBinding(workspaceId);
+        const contextToken = this.resolveContextTokenForFileSend(workspaceId, channelId, input.route.participantId);
+        const messageIds = [];
+        const attachments = [];
+        for (const part of input.parts || []) {
+            if (part.type === 'text') {
+                const text = String(part.text || '').trim();
+                if (text) {
+                    await this.sendTextMessage(state, channelId, text, contextToken);
+                    messageIds.push(`wx_text_${(0, node_crypto_2.randomUUID)()}`);
+                }
+                continue;
+            }
+            if (part.type === 'file') {
+                const sent = await this.sendFilePart(binding, channelId, part, contextToken);
+                messageIds.push(sent.messageId);
+                attachments.push({
+                    kind: 'file',
+                    attachmentId: sent.uploaded.fileKey,
+                    fileName: sent.file.fileName,
+                    fileSize: sent.file.fileSize,
+                    metadata: {
+                        fileKey: sent.uploaded.fileKey,
+                        encryptedQueryParam: sent.uploaded.encryptedQueryParam,
+                    },
+                });
+            }
+        }
+        return {
+            platform: 'weixin',
+            workspaceId,
+            channelId,
+            participantId: input.route.participantId,
+            messageIds,
+            attachments,
+        };
+    }
+    async sendFile(workspaceId, input) {
+        const result = await this.sendOutboundMessage(workspaceId, {
+            route: {
+                type: 'channel.chat',
+                channelId: input.channelId,
+                participantId: input.participantId,
+            },
+            parts: [{
+                    type: 'file',
+                    path: input.path,
+                    fileName: input.fileName,
+                }],
+        });
+        const attachment = result.attachments?.[0];
+        return {
+            platform: 'weixin',
+            workspaceId,
+            channelId: result.channelId,
+            messageId: result.messageIds[0] || '',
+            fileKey: String(attachment?.metadata?.fileKey || attachment?.attachmentId || ''),
+            fileName: attachment?.fileName || input.fileName || '',
+            fileSize: attachment?.fileSize || 0,
+        };
+    }
     // ==================== Inbound Message Handling ====================
     async handleInboundMessage(input) {
         if (this.isDuplicateInboundMessage(input)) {
@@ -585,7 +658,8 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return { paired: true, threadId };
         }
         this.options.store.updatePlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId, input.contextToken || input.messageId, 'weixin');
-        await router.sendThreadMessage(threadId, (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text));
+        const wrappedText = (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
+        await router.sendThreadMessage(threadId, this.createThreadMessageInput(wrappedText, input.contentParts));
         return { paired: true, threadId };
     }
     // ==================== Private: Bindings ====================
@@ -799,6 +873,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                     const msgId = msg.msg_id ?? String(Date.now());
                     // Handle attachments
                     let attachmentText = '';
+                    const attachmentParts = [];
                     if (mediaItems.length > 0) {
                         const uploadsDir = node_path_1.default.join(binding.stateDir, 'weixin-uploads');
                         for (const [idx, item] of mediaItems.entries()) {
@@ -807,6 +882,14 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                                 if (att) {
                                     attachmentText += attachmentText ? '\n' : '';
                                     attachmentText += att.kind === 'image' ? `[Image: ${att.path}]` : `[File "${att.name}": ${att.path}]`;
+                                    if (att.kind === 'image' && att.data) {
+                                        attachmentParts.push({
+                                            type: 'image',
+                                            data: att.data,
+                                            mimeType: att.mimeType,
+                                            fileName: att.name,
+                                        });
+                                    }
                                 }
                             }
                             catch (dlErr) {
@@ -825,6 +908,10 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                         text: fullText,
                         messageId: msgId,
                         contextToken: msg.context_token,
+                        contentParts: [
+                            ...(text ? [{ type: 'text', text }] : []),
+                            ...attachmentParts,
+                        ],
                     });
                 }
             }
@@ -935,9 +1022,123 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             base_info: { channel_version: WEIXIN_CHANNEL_VERSION },
         }, API_TIMEOUT_MS);
     }
+    async sendFileMessage(binding, toUserId, fileName, uploaded, contextToken) {
+        const clientId = `openclaw-weixin-${node_crypto_1.default.randomUUID()}`;
+        const resp = await this.apiPost(binding, 'ilink/bot/sendmessage', {
+            msg: {
+                from_user_id: '',
+                to_user_id: toUserId,
+                client_id: clientId,
+                message_type: 2,
+                message_state: 2,
+                item_list: [{
+                        type: FILE_ITEM_TYPE,
+                        file_item: {
+                            media: {
+                                encrypt_query_param: uploaded.encryptedQueryParam,
+                                aes_key: Buffer.from(uploaded.aesKeyHex).toString('base64'),
+                                encrypt_type: 1,
+                            },
+                            file_name: fileName,
+                            len: String(uploaded.fileSize),
+                        },
+                    }],
+                ...(contextToken ? { context_token: contextToken } : {}),
+            },
+            base_info: { channel_version: WEIXIN_CHANNEL_VERSION },
+        }, API_TIMEOUT_MS);
+        if (this.isSendMessageError(resp)) {
+            throw new Error(`WeChat send file failed: ret=${resp.ret} errcode=${resp.errcode}${resp.errmsg ? ` errmsg=${resp.errmsg}` : ''}`);
+        }
+        return clientId;
+    }
+    async sendFilePart(binding, channelId, part, contextToken) {
+        const file = await (0, file_utils_js_1.prepareChannelFile)({
+            path: part.path,
+            fileName: part.fileName,
+            maxBytes: WEIXIN_MAX_UPLOAD_FILE_SIZE,
+            platformLabel: 'WeChat',
+        });
+        const uploaded = await this.uploadFileToCdn(binding, channelId, file.path);
+        const messageId = await this.sendFileMessage(binding, channelId, file.fileName, uploaded, contextToken);
+        this.options.log?.(`localcore-weixin sent file ${file.fileName} (${file.fileSize} bytes) to ${channelId}`);
+        return {
+            messageId,
+            uploaded,
+            file,
+        };
+    }
     isSendMessageError(resp) {
         return (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
     }
+    async uploadFileToCdn(binding, toUserId, filePath) {
+        const plaintext = await node_fs_1.default.promises.readFile(filePath);
+        const fileKey = node_crypto_1.default.randomBytes(16).toString('hex');
+        const aesKey = node_crypto_1.default.randomBytes(16);
+        const aesKeyHex = aesKey.toString('hex');
+        const rawMd5 = node_crypto_1.default.createHash('md5').update(plaintext).digest('hex');
+        const cipherSize = this.getAesEcbPaddedSize(plaintext.length);
+        const uploadUrlResp = await this.apiPost(binding, 'ilink/bot/getuploadurl', {
+            filekey: fileKey,
+            media_type: UPLOAD_MEDIA_TYPE_FILE,
+            to_user_id: toUserId,
+            rawsize: plaintext.length,
+            rawfilemd5: rawMd5,
+            filesize: cipherSize,
+            no_need_thumb: true,
+            aeskey: aesKeyHex,
+            base_info: { channel_version: WEIXIN_CHANNEL_VERSION },
+        }, API_TIMEOUT_MS);
+        if (this.isSendMessageError(uploadUrlResp) || !uploadUrlResp.upload_param) {
+            throw new Error(`WeChat getuploadurl failed: ret=${uploadUrlResp.ret} errcode=${uploadUrlResp.errcode}${uploadUrlResp.errmsg ? ` errmsg=${uploadUrlResp.errmsg}` : ''}`);
+        }
+        const encryptedQueryParam = await this.uploadEncryptedBufferToCdn(binding, plaintext, uploadUrlResp.upload_param, fileKey, aesKey);
+        return {
+            fileKey,
+            encryptedQueryParam,
+            aesKeyHex,
+            fileSize: plaintext.length,
+            cipherSize,
+        };
+    }
+    async uploadEncryptedBufferToCdn(binding, plaintext, uploadParam, fileKey, aesKey) {
+        const cipher = node_crypto_1.default.createCipheriv('aes-128-ecb', aesKey, null);
+        const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        const url = `${binding.cdnBaseUrl.replace(/\/$/, '')}/upload?encrypted_query_param=${encodeURIComponent(uploadParam)}&filekey=${encodeURIComponent(fileKey)}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/octet-stream',
+            },
+            body: new Uint8Array(ciphertext),
+        });
+        if (!res.ok) {
+            throw new Error(`WeChat CDN upload failed: HTTP ${res.status}`);
+        }
+        const encryptedQueryParam = res.headers.get('x-encrypted-param') || '';
+        if (!encryptedQueryParam) {
+            throw new Error('WeChat CDN upload response missing x-encrypted-param');
+        }
+        return encryptedQueryParam;
+    }
+    getAesEcbPaddedSize(size) {
+        return Math.ceil((size + 1) / 16) * 16;
+    }
+    resolveContextTokenForFileSend(workspaceId, channelId, participantId) {
+        const preferredParticipantId = String(participantId || '').trim();
+        const direct = preferredParticipantId
+            ? this.options.store.getPlatformThreadBinding(workspaceId, channelId, preferredParticipantId, 'weixin')
+            : undefined;
+        if (direct?.last_platform_message_id) {
+            return direct.last_platform_message_id;
+        }
+        const users = this.options.store.listAuthorizedUsers(workspaceId, 'weixin');
+        const user = users.find((entry) => entry.chatId === channelId || entry.platformUserId === channelId);
+        if (!user) {
+            return '';
+        }
+        return this.options.store.getPlatformThreadBinding(workspaceId, user.chatId, user.platformUserId, 'weixin')?.last_platform_message_id || '';
+    }
     // ==================== Private: Attachment Download ====================
     sniffExtAndKind(buf) {
         if (buf[0] === 0xff && buf[1] === 0xd8)
@@ -991,7 +1192,41 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         const filePath = node_path_1.default.join(uploadsDir, fileName);
         node_fs_1.default.mkdirSync(uploadsDir, { recursive: true });
         node_fs_1.default.writeFileSync(filePath, resultBuf);
-        return { path: filePath, kind, name: declaredName };
+        return {
+            path: filePath,
+            kind,
+            name: declaredName,
+            data: kind === 'image' ? resultBuf.toString('base64') : undefined,
+            mimeType: kind === 'image' ? this.mimeTypeForImageExt(ext) : undefined,
+        };
+    }
+    createWrappedContentParts(wrappedText, parts) {
+        const nonTextParts = Array.isArray(parts)
+            ? parts.filter((part) => part.type !== 'text')
+            : [];
+        return [
+            { type: 'text', text: wrappedText },
+            ...nonTextParts,
+        ];
+    }
+    createThreadMessageInput(wrappedText, parts) {
+        const hasNonTextPart = Array.isArray(parts) && parts.some((part) => part.type !== 'text');
+        if (!hasNonTextPart) {
+            return wrappedText;
+        }
+        return {
+            displayText: wrappedText,
+            contentParts: this.createWrappedContentParts(wrappedText, parts),
+        };
+    }
+    mimeTypeForImageExt(ext) {
+        if (ext === '.jpg')
+            return 'image/jpeg';
+        if (ext === '.png')
+            return 'image/png';
+        if (ext === '.gif')
+            return 'image/gif';
+        return 'application/octet-stream';
     }
     // ==================== Private: Turn State ====================
     createTurnState(sessionKey) {

package/dist-electron/services/local-ai-core/src/cli/lac.js

@@ -10,11 +10,20 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
     try {
         const { positionals, flags } = parseArgs(argv);
         const [domain = '', action = '', maybeId = ''] = positionals;
+        const json = getBooleanFlag(flags, 'json', false);
+        if (domain === 'channel') {
+            switch (action) {
+                case 'send-file':
+                    return await handleChannelSendFile(flags, env, io, json);
+                default:
+                    printUsage(io.stderr);
+                    return 2;
+            }
+        }
         if (domain !== 'scheduler') {
             printUsage(io.stderr);
             return 2;
         }
-        const json = getBooleanFlag(flags, 'json', false);
         switch (action) {
             case 'add':
                 return await handleAdd(flags, env, io, json);
@@ -39,6 +48,36 @@ async function runCli(argv, env = node_process_1.default.env, io = node_process_
         return 1;
     }
 }
+async function handleChannelSendFile(flags, env, io, json) {
+    const context = resolveContext(flags, env);
+    const filePath = getRequiredFlag(flags, 'path');
+    const platform = getFlag(flags, 'platform') || context.platform;
+    if (!platform) {
+        throw new Error('channel send-file requires a platform. Set LOCAL_AI_PLATFORM or pass --platform.');
+    }
+    if (!context.workspaceId) {
+        throw new Error('channel send-file requires a workspace context. Set LOCAL_AI_WORKSPACE_ID or pass --workspace.');
+    }
+    const target = getFlag(flags, 'target') || getFlag(flags, 'chat-id') || context.chatId;
+    if (!target) {
+        throw new Error('channel send-file requires a target. Set LOCAL_AI_CHAT_ID or pass --target.');
+    }
+    const result = await request(context.baseUrl, 'POST', `/platforms/${encodeURIComponent(platform)}/${encodeURIComponent(context.workspaceId)}/messages`, {
+        route: {
+            type: 'channel.chat',
+            channelId: target,
+            participantId: getFlag(flags, 'participant-id') || context.platformUserId || undefined,
+        },
+        parts: [{
+                type: 'file',
+                path: filePath,
+                fileName: getFlag(flags, 'name') || undefined,
+            }],
+    });
+    const file = result.attachments?.[0];
+    print(json, io.stdout, result, `Sent file ${file?.fileName || filePath} to ${result.channelId}: ${result.messageIds[0] || ''}`);
+    return 0;
+}
 async function handleAdd(flags, env, io, json) {
     const cronExpr = getRequiredFlag(flags, 'cron');
     const promptTemplate = getRequiredFlag(flags, 'message');
@@ -265,6 +304,7 @@ function printUsage(output) {
         '  lac scheduler edit <job-id> [--cron "<expr>"] [--message "<text>"] [--desc "<label>"] [--enabled true|false] [--execution-mode same-thread|side-thread] [--json]',
         '  lac scheduler del <job-id> [--json]',
         '  lac scheduler run <job-id> [--json]',
+        '  lac channel send-file --path "<file>" [--target <chat-or-user-id>] [--workspace <id>] [--platform lark] [--name <filename>] [--json]',
     ].join('\n') + '\n');
 }
 function formatJobLine(job) {

package/dist-electron/services/local-ai-core/src/kernel/bootstrap.js

@@ -35,7 +35,7 @@ function bootstrapLocalCoreKernel(options) {
     const lifecycle = new lifecycle_manager_js_1.LocalCoreLifecycleManager(plugins, context);
     const diagnostics = new diagnostics_js_1.LocalCoreDiagnostics(plugins, lifecycle);
     const builtIns = [
-        ...['codex', 'cursor', 'gemini', 'qoder', 'iflow'].map((agentType) => (0, agent_localcore_acp_plugin_js_1.createBuiltinStaticAgentCapabilityPlugin)(agentType)),
+        ...['cursor', 'gemini', 'qoder', 'iflow'].map((agentType) => (0, agent_localcore_acp_plugin_js_1.createBuiltinStaticAgentCapabilityPlugin)(agentType)),
         (0, agent_localcore_acp_plugin_js_1.createBuiltinLocalCoreAcpAgentPlugin)(),
         (0, scheduler_cron_plugin_js_1.createBuiltinCronSchedulerPlugin)(),
     ];
@@ -164,6 +164,7 @@ function bootstrapLocalCoreRuntime(options) {
     const agentPlugins = [
         localCoreAgentPlugin,
         (0, agent_localcore_acp_plugin_js_1.createBuiltinOpencodeAgentPlugin)(),
+        (0, agent_localcore_acp_plugin_js_1.createBuiltinCodexAgentPlugin)(),
         (0, agent_localcore_acp_plugin_js_1.createBuiltinClaudeCodeAgentPlugin)(),
     ];
     let workspaceRouter;

package/dist-electron/services/local-ai-core/src/plugins/builtin/agent-localcore-acp-plugin.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinLocalCoreAcpAgentPlugin = createBuiltinLocalCoreAcpAgentPlugin;
 exports.createBuiltinOpencodeAgentPlugin = createBuiltinOpencodeAgentPlugin;
+exports.createBuiltinCodexAgentPlugin = createBuiltinCodexAgentPlugin;
 exports.createBuiltinClaudeCodeAgentPlugin = createBuiltinClaudeCodeAgentPlugin;
 exports.createBuiltinStaticAgentCapabilityPlugin = createBuiltinStaticAgentCapabilityPlugin;
 const desktop_js_1 = require("../../../../../shared/desktop.js");
@@ -85,6 +86,14 @@ function createBuiltinOpencodeAgentPlugin() {
         displayName: 'OpenCode',
     });
 }
+function createBuiltinCodexAgentPlugin() {
+    return createBuiltinAgentPlugin({
+        pluginId: 'builtin.agent-codex',
+        agentType: 'codex',
+        match: (normalizedAgentType) => normalizedAgentType === 'codex',
+        displayName: 'Codex',
+    });
+}
 function createBuiltinClaudeCodeAgentPlugin() {
     return createBuiltinAgentPlugin({
         pluginId: 'builtin.agent-claudecode',

package/dist-electron/services/local-ai-core/src/plugins/builtin/channel-lark-plugin.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinLarkChannelPlugin = createBuiltinLarkChannelPlugin;
-const local_core_lark_gateway_js_1 = require("../../gateway/local-core-lark-gateway.js");
+const local_core_lark_gateway_js_1 = require("../../channel/lark/local-core-lark-gateway.js");
 function createBuiltinLarkChannelPlugin(options) {
     let runtime = null;
     let unsubscribeBridgeEvents = null;

package/dist-electron/services/local-ai-core/src/plugins/builtin/channel-weixin-plugin.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinWeixinChannelPlugin = createBuiltinWeixinChannelPlugin;
-const local_core_weixin_gateway_js_1 = require("../../gateway/local-core-weixin-gateway.js");
+const local_core_weixin_gateway_js_1 = require("../../channel/weixin/local-core-weixin-gateway.js");
 function createBuiltinWeixinChannelPlugin(options) {
     let runtime = null;
     let unsubscribeBridgeEvents = null;

package/dist-electron/services/local-ai-core/src/router/workspace-route-config.js

@@ -150,22 +150,28 @@ function shouldUseOpenAiCompatibleProvider(providerId) {
     ]);
     return !builtInNonCompatibleProviders.has(providerId);
 }
-function resolveBundledClaudeCodeCommand() {
+function resolveBundledAcpCommand(packageName, binName) {
     const require = (0, node_module_1.createRequire)(__filename);
-    const packageJsonPath = require.resolve(`${desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE}/package.json`);
+    const packageJsonPath = require.resolve(`${packageName}/package.json`);
     const packageJson = require(packageJsonPath);
     const binField = packageJson.bin;
     const relativeBinPath = typeof binField === 'string'
         ? binField
-        : binField?.['claude-agent-acp'];
+        : binField?.[binName];
     if (!relativeBinPath) {
-        throw new Error(`Bundled package "${desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE}" does not declare the claude-agent-acp bin.`);
+        throw new Error(`Bundled package "${packageName}" does not declare the ${binName} bin.`);
     }
     return {
         command: process.execPath,
         args: [(0, node_path_1.resolve)((0, node_path_1.dirname)(packageJsonPath), relativeBinPath)],
     };
 }
+function resolveBundledCodexCommand() {
+    return resolveBundledAcpCommand(desktop_js_1.DESKTOP_CODEX_ACP_PACKAGE, 'codex-acp');
+}
+function resolveBundledClaudeCodeCommand() {
+    return resolveBundledAcpCommand(desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE, 'claude-agent-acp');
+}
 function toLocalCoreProjectConfig(configState, project) {
     const rawWorkDir = String(project.agent?.options?.work_dir || '.').trim() || '.';
     const configDir = (0, node_path_1.dirname)(configState.path);
@@ -198,21 +204,26 @@ function toLocalCoreProjectConfig(configState, project) {
             ANTHROPIC_MODEL: model,
         }
         : {};
+    const bundledCodex = agentType === 'codex'
+        ? resolveBundledCodexCommand()
+        : null;
     const bundledClaudeCode = agentType === 'claudecode'
         ? resolveBundledClaudeCodeCommand()
         : null;
     const inferredCommand = agentType === 'opencode'
         ? 'opencode'
-        : bundledClaudeCode?.command || '';
+        : bundledCodex?.command || bundledClaudeCode?.command || '';
     const command = String(project.agent?.options?.command || inferredCommand).trim();
     if (!command) {
         throw new Error(`Workspace "${project.name}" requires [projects.agent.options].command for Local AI Core ACP execution.`);
     }
     const defaultArgs = agentType === 'opencode'
         ? ['acp']
-        : agentType === 'claudecode'
-            ? [...(bundledClaudeCode?.args || [])]
-            : [];
+        : agentType === 'codex'
+            ? [...(bundledCodex?.args || [])]
+            : agentType === 'claudecode'
+                ? [...(bundledClaudeCode?.args || [])]
+                : [];
     return {
         workspaceId: project.name,
         agentType,

package/dist-electron/services/local-ai-core/src/runtime/agent-runtime-detector.js

@@ -18,7 +18,7 @@ const DISPLAY_NAMES = {
 };
 const COMMAND_CANDIDATES = {
     opencode: ['opencode'],
-    codex: ['codex'],
+    codex: ['codex-acp', 'codex'],
     claudecode: ['claude-agent-acp'],
     cursor: ['cursor-agent', 'cursor'],
     gemini: ['gemini'],
@@ -61,8 +61,14 @@ function detectInstalledAgentRuntimes(options = {}) {
                 ? installedRuntime(agentType, resolved, 'config', detectedAt, env, versionTimeoutMs)
                 : missingRuntime(agentType, detectedAt, `Configured command not found: ${configured}`);
         }
-        if (agentType === 'claudecode') {
-            const bundled = resolveBundledClaudeAgentAcp(options.requireFrom);
+        if (agentType === 'codex' || agentType === 'claudecode') {
+            const bundled = agentType === 'codex'
+                ? resolveBundledAcpPackage(options.requireFrom, desktop_js_1.DESKTOP_CODEX_ACP_PACKAGE, ['bin/codex-acp.js'])
+                : resolveBundledAcpPackage(options.requireFrom, desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE, [
+                    'dist/cli.js',
+                    'bin/claude-agent-acp.js',
+                    'cli.js',
+                ]);
             if (bundled) {
                 return installedRuntime(agentType, bundled, 'bundled', detectedAt, env, versionTimeoutMs);
             }
@@ -215,18 +221,23 @@ function parseVersionOutput(output) {
     const match = text.match(/\d+(?:\.\d+)+(?:[-+._a-zA-Z0-9]*)?/);
     return match?.[0] || text || undefined;
 }
-function resolveBundledClaudeAgentAcp(requireFrom) {
+function resolveBundledAcpPackage(requireFrom, packageName, candidates) {
     try {
         const require = (0, node_module_1.createRequire)(requireFrom || (0, node_path_1.join)(process.cwd(), 'package.json'));
-        const packageJsonPath = require.resolve(`${desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE}/package.json`);
+        const packageJsonPath = require.resolve(`${packageName}/package.json`);
         const packageDir = (0, node_path_1.dirname)(packageJsonPath);
-        for (const candidate of [
-            (0, node_path_1.join)(packageDir, 'dist', 'cli.js'),
-            (0, node_path_1.join)(packageDir, 'bin', 'claude-agent-acp.js'),
-            (0, node_path_1.join)(packageDir, 'cli.js'),
-        ]) {
-            if ((0, node_fs_1.existsSync)(candidate)) {
-                return candidate;
+        const packageJson = require(packageJsonPath);
+        const binField = packageJson.bin;
+        if (typeof binField === 'string') {
+            candidates = [binField, ...candidates];
+        }
+        else if (binField && typeof binField === 'object') {
+            candidates = [...Object.values(binField), ...candidates];
+        }
+        for (const candidate of candidates) {
+            const candidatePath = (0, node_path_1.join)(packageDir, candidate);
+            if ((0, node_fs_1.existsSync)(candidatePath)) {
+                return candidatePath;
             }
         }
         return packageJsonPath;

package/dist-electron/services/local-ai-core/src/runtime/local-core-controller.js

@@ -343,6 +343,47 @@ class LocalCoreController extends node_events_1.EventEmitter {
     async listChannelAuthorizedUsers(platform, workspaceId) {
         return this.resolveChannelRuntime(platform).listAuthorizedUsers(workspaceId);
     }
+    async sendChannelFile(platform, workspaceId, input) {
+        const runtime = this.resolveChannelRuntime(platform);
+        if (runtime.sendOutboundMessage) {
+            const result = await runtime.sendOutboundMessage(workspaceId, {
+                route: {
+                    type: 'channel.chat',
+                    channelId: input.channelId,
+                    participantId: input.participantId,
+                },
+                parts: [{
+                        type: 'file',
+                        path: input.path,
+                        fileName: input.fileName,
+                    }],
+            });
+            const attachment = result.attachments?.[0];
+            return {
+                platform: result.platform,
+                workspaceId: result.workspaceId,
+                channelId: result.channelId,
+                messageId: result.messageIds[0] || '',
+                messageIds: result.messageIds,
+                fileKey: String(attachment?.metadata?.fileKey || attachment?.attachmentId || ''),
+                attachmentId: attachment?.attachmentId,
+                fileName: attachment?.fileName || input.fileName || '',
+                fileSize: attachment?.fileSize || 0,
+                metadata: result.metadata,
+            };
+        }
+        if (!runtime.sendFile) {
+            throw new Error(`Channel platform does not support sending files: ${platform}`);
+        }
+        return runtime.sendFile(workspaceId, input);
+    }
+    async sendChannelMessage(platform, workspaceId, input) {
+        const runtime = this.resolveChannelRuntime(platform);
+        if (!runtime.sendOutboundMessage) {
+            throw new Error(`Channel platform does not support outbound messages: ${platform}`);
+        }
+        return runtime.sendOutboundMessage(workspaceId, input);
+    }
     async getWeixinQrCode(workspaceId) {
         const runtime = this.weixinChannelRuntime;
         return runtime.getQrCode(workspaceId);

package/dist-electron/services/local-ai-core/src/runtime/server.js

@@ -249,6 +249,16 @@ class LocalAiCoreServer {
                     json(res, 200, await this.bindings.disableChannelGateway(platform, workspaceOrCollection));
                     return;
                 }
+                if (action === 'files') {
+                    const body = await readJsonBody(req);
+                    json(res, 200, await this.bindings.sendChannelFile(platform, workspaceOrCollection, body));
+                    return;
+                }
+                if (action === 'messages') {
+                    const body = await readJsonBody(req);
+                    json(res, 200, await this.bindings.sendChannelMessage(platform, workspaceOrCollection, body));
+                    return;
+                }
                 if (platform === 'weixin' && segments.length === 3 && workspaceOrCollection !== 'pairings' && action === 'qrcode') {
                     json(res, 200, await this.bindings.getWeixinQrCode(workspaceOrCollection));
                     return;