@kafca/agentdock 0.1.56 → 0.1.57

package/dist-electron/services/local-ai-core/src/channel/lark/gateway-utils.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeLarkInboundContentParts = summarizeLarkInboundContentParts;
+exports.extractLarkHeaderMimeType = extractLarkHeaderMimeType;
+exports.sniffLarkImageMimeType = sniffLarkImageMimeType;
+exports.sniffLarkImageExtension = sniffLarkImageExtension;
+exports.attachLarkWsDiagnostics = attachLarkWsDiagnostics;
+exports.maskLarkAppId = maskLarkAppId;
+function summarizeLarkInboundContentParts(parts) {
+    const text = parts
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text)
+        .filter(Boolean)
+        .join('\n\n')
+        .trim();
+    if (text)
+        return text;
+    return parts
+        .map((part) => part.type === 'image'
+        ? '[Image]'
+        : part.type === 'file'
+            ? part.fileName ? `[File: ${part.fileName}]` : '[File]'
+            : '')
+        .filter(Boolean)
+        .join('\n');
+}
+function extractLarkHeaderMimeType(headers) {
+    const value = headers && typeof headers === 'object'
+        ? headers['content-type'] || headers['Content-Type']
+        : '';
+    return String(value || '').split(';')[0]?.trim() || '';
+}
+function sniffLarkImageMimeType(buffer) {
+    if (buffer[0] === 0xff && buffer[1] === 0xd8)
+        return 'image/jpeg';
+    if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47)
+        return 'image/png';
+    if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46)
+        return 'image/gif';
+    if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46)
+        return 'image/webp';
+    return 'application/octet-stream';
+}
+function sniffLarkImageExtension(buffer) {
+    const mimeType = sniffLarkImageMimeType(buffer);
+    if (mimeType === 'image/jpeg')
+        return 'jpg';
+    if (mimeType === 'image/png')
+        return 'png';
+    if (mimeType === 'image/gif')
+        return 'gif';
+    if (mimeType === 'image/webp')
+        return 'webp';
+    return 'bin';
+}
+function summarizeWsArgs(args) {
+    if (args.length === 0)
+        return 'no-args';
+    return args.map((arg) => {
+        if (arg instanceof Error)
+            return `${arg.name}: ${arg.message}`;
+        if (typeof arg === 'string')
+            return arg.slice(0, 200);
+        if (arg && typeof arg === 'object')
+            return JSON.stringify(Object.keys(arg));
+        return String(arg);
+    }).join(' ');
+}
+function attachLarkWsDiagnostics(workspaceId, wsClient, log) {
+    const on = typeof wsClient?.on === 'function' ? wsClient.on.bind(wsClient) : null;
+    if (!on) {
+        log?.(`localcore-lark ws diagnostics unavailable for ${workspaceId}: client has no on()`);
+        return;
+    }
+    for (const eventName of ['open', 'connect', 'connected', 'ready', 'close', 'closed', 'disconnect', 'error', 'reconnect']) {
+        try {
+            on(eventName, (...args) => {
+                log?.(`localcore-lark ws event ${eventName} for ${workspaceId}: ${summarizeWsArgs(args)}`);
+            });
+        }
+        catch (error) {
+            log?.(`localcore-lark ws diagnostic hook failed for ${workspaceId} event=${eventName}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+function maskLarkAppId(appId) {
+    const value = String(appId || '').trim();
+    if (value.length <= 8)
+        return value ? '***' : '';
+    return `${value.slice(0, 6)}...${value.slice(-4)}`;
+}

package/dist-electron/services/local-ai-core/src/channel/lark/inbound-handler.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LarkInboundHandler = void 0;
+const node_path_1 = require("node:path");
+const inbound_attachment_store_js_1 = require("../shared/inbound-attachment-store.js");
+const channel_keys_js_1 = require("../shared/channel-keys.js");
+const inbound_js_1 = require("./inbound.js");
+const gateway_utils_js_1 = require("./gateway-utils.js");
+const LARK_MAX_INBOUND_FILE_SIZE = 30 * 1024 * 1024;
+class LarkInboundHandler {
+    options;
+    attachmentStore = new inbound_attachment_store_js_1.FileSystemInboundAttachmentStore();
+    constructor(options) {
+        this.options = options;
+    }
+    async handleMessageEvent(workspaceId, instanceIdOrData, platformKeyOrData, maybeData) {
+        const legacyCall = typeof instanceIdOrData === 'object';
+        const instanceId = legacyCall ? 'default' : instanceIdOrData;
+        const platformKey = legacyCall ? 'lark' : String(platformKeyOrData || (0, channel_keys_js_1.channelPlatformKey)('lark', instanceId));
+        const data = (legacyCall ? instanceIdOrData : maybeData) || {};
+        const runtimeState = this.options.getRuntimeState(workspaceId, instanceId);
+        const normalized = (0, inbound_js_1.normalizeLarkInboundMessageEvent)(data, {
+            botOpenId: runtimeState?.botOpenId,
+            groupReplyAll: runtimeState?.groupReplyAll,
+        });
+        this.options.log?.(`localcore-lark handling message event for ${workspaceId}: ${(0, inbound_js_1.summarizeLarkInboundPayload)(data)}`);
+        if (!normalized.ok) {
+            this.options.log?.(`localcore-lark ignored message event for ${workspaceId}: reason=${normalized.reason}${normalized.detail ? ` ${normalized.detail}` : ''}`);
+            return;
+        }
+        const { message, parsedContent, messageType, chatType, mentions, text, platformUserId, chatId, displayName, messageId, } = normalized.message;
+        const mayMaterializeAttachments = Boolean(runtimeState?.autoApprove || this.options.store.getAuthorizedUser(workspaceId, platformUserId, platformKey));
+        const contentParts = text ? [{ type: 'text', text }] : [];
+        if (messageType === 'image') {
+            const imageKey = String(parsedContent.image_key || parsedContent.file_key || '').trim();
+            if (imageKey) {
+                if (!mayMaterializeAttachments) {
+                    contentParts.push({ type: 'text', text: '[Image]' });
+                }
+                else {
+                    try {
+                        contentParts.push(await this.downloadMessageImage(workspaceId, String(message.message_id || ''), imageKey, instanceId));
+                    }
+                    catch (error) {
+                        contentParts.push({ type: 'text', text: `[Image download failed: ${error instanceof Error ? error.message : String(error)}]` });
+                        this.options.log?.(`localcore-lark image download failed for ${workspaceId}: message=${String(message.message_id || '')} imageKey=${imageKey} error=${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+        }
+        if (messageType === 'file') {
+            const fileKey = String(parsedContent.file_key || '').trim();
+            if (fileKey) {
+                if (!mayMaterializeAttachments) {
+                    const inboundFileName = String(parsedContent.file_name || parsedContent.name || '').trim();
+                    contentParts.push({ type: 'text', text: inboundFileName ? `[File: ${inboundFileName}]` : '[File]' });
+                }
+                else {
+                    try {
+                        contentParts.push(await this.downloadMessageFile(workspaceId, String(message.message_id || ''), fileKey, String(parsedContent.file_name || parsedContent.name || '').trim(), instanceId));
+                    }
+                    catch (error) {
+                        contentParts.push({ type: 'text', text: `[File download failed: ${error instanceof Error ? error.message : String(error)}]` });
+                        this.options.log?.(`localcore-lark file download failed for ${workspaceId}: message=${String(message.message_id || '')} fileKey=${fileKey} error=${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
+        }
+        if (contentParts.length === 0) {
+            this.options.log?.(`localcore-lark ignored unsupported message for ${workspaceId}: type=${String(message.message_type || 'unknown')} contentKeys=${JSON.stringify(Object.keys(parsedContent))}`);
+            return;
+        }
+        const displayText = text || (0, gateway_utils_js_1.summarizeLarkInboundContentParts)(contentParts);
+        this.options.log?.(`localcore-lark inbound message for ${workspaceId}: chat=${chatId} user=${platformUserId} chatType=${chatType || 'unknown'} mentions=${mentions.length} type=${messageType || 'unknown'} text=${JSON.stringify(displayText.slice(0, 120))}`);
+        await this.options.dispatchInboundMessage({
+            workspaceId,
+            instanceId,
+            platformKey,
+            platformUserId,
+            chatId,
+            displayName,
+            text: displayText,
+            messageId,
+            contentParts,
+        });
+    }
+    async downloadMessageImage(workspaceId, messageId, imageKey, instanceId = 'default') {
+        const state = this.options.getRuntimeState(workspaceId, instanceId);
+        if (!state?.client)
+            throw new Error('Lark client is not connected');
+        if (!messageId)
+            throw new Error('Lark image message is missing message_id');
+        const downloadsDir = await this.resolveDownloadsDir(workspaceId, instanceId, state.downloadsDir);
+        const stored = await this.attachmentStore.save({
+            directory: downloadsDir,
+            storedFileName: `${messageId}-${imageKey}`,
+            displayFileName: imageKey,
+            maxBytes: LARK_MAX_INBOUND_FILE_SIZE,
+            includeBase64: true,
+            finalizeStoredFileName: ({ storedFileName, prefix }) => `${storedFileName}.${(0, gateway_utils_js_1.sniffLarkImageExtension)(prefix)}`,
+            source: {
+                open: async () => {
+                    const resource = await state.client.im.messageResource.get({
+                        path: { message_id: messageId, file_key: imageKey },
+                        params: { type: 'image' },
+                    });
+                    const stream = resource?.getReadableStream?.();
+                    if (!stream || typeof stream.pipe !== 'function')
+                        throw new Error('Lark image resource did not provide a readable stream');
+                    return { stream, mimeType: (0, gateway_utils_js_1.extractLarkHeaderMimeType)(resource?.headers) };
+                },
+            },
+        });
+        const extension = (0, node_path_1.extname)(stored.path).slice(1) || 'bin';
+        const uri = await this.resolveAttachmentUri(workspaceId, stored.path, instanceId);
+        return {
+            type: 'image',
+            data: stored.data || '',
+            ...(uri ? { uri } : {}),
+            mimeType: stored.mimeType || (0, gateway_utils_js_1.sniffLarkImageMimeType)(stored.prefix),
+            fileName: `${imageKey}.${extension}`,
+        };
+    }
+    async downloadMessageFile(workspaceId, messageId, fileKey, fileName, instanceId = 'default') {
+        const state = this.options.getRuntimeState(workspaceId, instanceId);
+        if (!state?.client)
+            throw new Error('Lark client is not connected');
+        if (!messageId)
+            throw new Error('Lark file message is missing message_id');
+        const downloadsDir = await this.resolveDownloadsDir(workspaceId, instanceId, state.downloadsDir);
+        const displayFileName = fileName || fileKey;
+        const stored = await this.attachmentStore.save({
+            directory: downloadsDir,
+            storedFileName: `${messageId}-${displayFileName}`,
+            displayFileName,
+            maxBytes: LARK_MAX_INBOUND_FILE_SIZE,
+            source: {
+                open: async () => {
+                    const resource = await state.client.im.messageResource.get({
+                        path: { message_id: messageId, file_key: fileKey },
+                        params: { type: 'file' },
+                    });
+                    const stream = resource?.getReadableStream?.();
+                    if (!stream || typeof stream.pipe !== 'function')
+                        throw new Error('Lark file resource did not provide a readable stream');
+                    return { stream, mimeType: (0, gateway_utils_js_1.extractLarkHeaderMimeType)(resource?.headers) || 'application/octet-stream' };
+                },
+            },
+        });
+        return { type: 'file', path: stored.path, fileName: stored.fileName, mimeType: stored.mimeType, size: stored.size };
+    }
+    async resolveDownloadsDir(workspaceId, instanceId, runtimeDownloadsDir) {
+        const binding = runtimeDownloadsDir === undefined ? await this.options.getBinding(workspaceId, instanceId) : undefined;
+        const configuredDir = String(runtimeDownloadsDir ?? binding?.downloadsDir ?? '').trim();
+        if (configuredDir && (0, node_path_1.isAbsolute)(configuredDir))
+            return configuredDir;
+        const workspace = await this.options.getWorkspaceRouter().getWorkspaceRegistryEntry(workspaceId);
+        return configuredDir
+            ? (0, node_path_1.resolve)(workspace.path, configuredDir)
+            : (0, node_path_1.join)(workspace.path, '.agentdock', 'channel-uploads', 'lark', instanceId);
+    }
+    async resolveAttachmentUri(workspaceId, filePath, instanceId) {
+        const binding = await this.options.getBinding(workspaceId, instanceId).catch(() => undefined);
+        if (!binding)
+            return undefined;
+        const sandbox = binding.project.agent?.options?.sandbox;
+        if (!sandbox?.enabled)
+            return (0, inbound_attachment_store_js_1.resolveInboundAttachmentUri)({ filePath });
+        const workspace = await this.options.getWorkspaceRouter().getWorkspaceRegistryEntry(workspaceId).catch(() => undefined);
+        if (!workspace)
+            return undefined;
+        return (0, inbound_attachment_store_js_1.resolveInboundAttachmentUri)({
+            filePath,
+            workspacePath: workspace.path,
+            sandboxEnabled: true,
+            sandboxWorkspacePath: sandbox.workspace_mount_path,
+        });
+    }
+}
+exports.LarkInboundHandler = LarkInboundHandler;