@kafca/agentdock 0.1.55 → 0.1.57

package/dist-electron/services/local-ai-core/src/channel/lark/outbound-transport.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LarkOutboundTransport = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const file_utils_js_1 = require("../shared/file-utils.js");
+const cards_js_1 = require("./cards.js");
+const messages_js_1 = require("./rendering/messages.js");
+const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
+class LarkOutboundTransport {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    async sendFilePart(state, channelId, part) {
+        const file = await (0, file_utils_js_1.prepareChannelFile)({
+            path: part.path,
+            fileName: part.fileName,
+            workspacePath: typeof part.metadata?.workspacePath === 'string' ? part.metadata.workspacePath : undefined,
+            maxBytes: LARK_MAX_UPLOAD_FILE_SIZE,
+            platformLabel: 'Lark',
+        });
+        const upload = await state.client.im.file.create({
+            data: {
+                file_type: resolveLarkUploadFileType(file.fileName),
+                file_name: file.fileName,
+                file: (0, node_fs_1.createReadStream)(file.path),
+            },
+        });
+        const fileKey = String(upload?.file_key || upload?.data?.file_key || '').trim();
+        if (!fileKey) {
+            throw new Error('Lark file upload did not return a file key');
+        }
+        const response = await state.client.im.message.create({
+            params: {
+                receive_id_type: resolveReceiveIdType(channelId),
+            },
+            data: {
+                receive_id: channelId,
+                msg_type: 'file',
+                content: JSON.stringify({ file_key: fileKey }),
+            },
+        });
+        const messageId = String(response?.data?.message_id || '').trim();
+        if (!messageId) {
+            throw new Error('Lark file message did not return a message id');
+        }
+        this.log?.(`localcore-lark sent file ${file.fileName} (${file.fileSize} bytes) to ${channelId}`);
+        return { messageId, fileKey, file };
+    }
+    async sendTextAsCard(state, chatId, text, buttonRows = [], sessionKey, threadId) {
+        const startedAt = Date.now();
+        const response = await state.client.im.message.create({
+            params: { receive_id_type: resolveReceiveIdType(chatId) },
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)),
+            },
+        });
+        this.log?.(`localcore-lark card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
+        return String(response?.data?.message_id || '').trim();
+    }
+    async sendSessionCommandCard(state, chatId, text, actionRows, sessionKey, threadId) {
+        const startedAt = Date.now();
+        const response = await state.client.im.message.create({
+            params: { receive_id_type: resolveReceiveIdType(chatId) },
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: JSON.stringify((0, cards_js_1.buildSessionCommandCard)(text, actionRows, sessionKey, threadId)),
+            },
+        });
+        this.log?.(`localcore-lark session card create took ${Date.now() - startedAt}ms textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
+        return String(response?.data?.message_id || '').trim();
+    }
+    async sendTextAsMessage(state, chatId, text) {
+        const startedAt = Date.now();
+        const rendered = (0, messages_js_1.renderLarkTextMessage)(text);
+        const response = await state.client.im.message.create({
+            params: { receive_id_type: resolveReceiveIdType(chatId) },
+            data: {
+                receive_id: chatId,
+                msg_type: rendered.msgType,
+                content: JSON.stringify(rendered.content),
+            },
+        });
+        this.log?.(`localcore-lark ${rendered.renderKind} create took ${Date.now() - startedAt}ms msgType=${rendered.msgType} reason=${rendered.reason} tableCount=${rendered.tableCount} textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
+        return {
+            messageId: String(response?.data?.message_id || '').trim(),
+            renderKind: rendered.renderKind,
+            msgType: rendered.msgType,
+        };
+    }
+    async patchTextCard(state, messageId, text, buttonRows = [], sessionKey, threadId) {
+        const startedAt = Date.now();
+        await state.client.im.message.patch({
+            path: { message_id: messageId },
+            data: { content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)) },
+        });
+        this.log?.(`localcore-lark card patch took ${Date.now() - startedAt}ms message=${messageId} textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
+    }
+}
+exports.LarkOutboundTransport = LarkOutboundTransport;
+function resolveReceiveIdType(receiveId) {
+    return receiveId.startsWith('oc_') ? 'chat_id' : receiveId.startsWith('ou_') ? 'open_id' : 'user_id';
+}
+function resolveLarkUploadFileType(fileName) {
+    switch ((0, node_path_1.extname)(fileName).toLowerCase()) {
+        case '.opus': return 'opus';
+        case '.mp4':
+        case '.mov':
+        case '.m4v': return 'mp4';
+        case '.pdf': return 'pdf';
+        case '.doc':
+        case '.docx': return 'doc';
+        case '.xls':
+        case '.xlsx':
+        case '.csv': return 'xls';
+        case '.ppt':
+        case '.pptx': return 'ppt';
+        default: return 'stream';
+    }
+}

package/dist-electron/services/local-ai-core/src/channel/shared/inbound-attachment-store.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemInboundAttachmentStore = void 0;
+exports.sanitizeInboundFilePart = sanitizeInboundFilePart;
+exports.resolveInboundAttachmentUri = resolveInboundAttachmentUri;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const promises_2 = require("node:stream/promises");
+const node_url_1 = require("node:url");
+class FileSystemInboundAttachmentStore {
+    async save(input) {
+        const storedFileName = sanitizeInboundFilePart(input.storedFileName, 'file');
+        const temporaryPath = (0, node_path_1.join)(input.directory, `.${storedFileName}.${(0, node_crypto_1.randomUUID)()}.part`);
+        await (0, promises_1.mkdir)(input.directory, { recursive: true });
+        const opened = await input.source.open();
+        let size = 0;
+        let prefix = Buffer.alloc(0);
+        const sizeLimiter = new node_stream_1.Transform({
+            transform(chunk, _encoding, callback) {
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                if (prefix.length < 16) {
+                    prefix = Buffer.concat([prefix, buffer.subarray(0, 16 - prefix.length)]);
+                }
+                size += buffer.length;
+                if (input.maxBytes && size > input.maxBytes) {
+                    callback(new Error(`Inbound attachment exceeds ${input.maxBytes} bytes`));
+                    return;
+                }
+                callback(null, buffer);
+            },
+        });
+        let filePath = '';
+        try {
+            await (0, promises_2.pipeline)(opened.stream, sizeLimiter, (0, node_fs_1.createWriteStream)(temporaryPath, { flags: 'wx' }));
+            if (size === 0) {
+                throw new Error('Inbound attachment is empty');
+            }
+            const finalizedName = input.finalizeStoredFileName
+                ? input.finalizeStoredFileName({ storedFileName, prefix })
+                : storedFileName;
+            filePath = (0, node_path_1.join)(input.directory, sanitizeInboundFilePart(finalizedName, storedFileName));
+            await (0, promises_1.rename)(temporaryPath, filePath);
+            const includeBase64 = typeof input.includeBase64 === 'function'
+                ? input.includeBase64({ prefix })
+                : input.includeBase64;
+            const data = includeBase64
+                ? (await (0, promises_1.readFile)(filePath)).toString('base64')
+                : undefined;
+            const fileStat = await (0, promises_1.stat)(filePath);
+            return {
+                path: filePath,
+                fileName: input.displayFileName,
+                mimeType: opened.mimeType,
+                size: fileStat.size,
+                data,
+                prefix,
+            };
+        }
+        catch (error) {
+            await (0, promises_1.rm)(temporaryPath, { force: true }).catch(() => undefined);
+            if (filePath) {
+                await (0, promises_1.rm)(filePath, { force: true }).catch(() => undefined);
+            }
+            throw error;
+        }
+    }
+}
+exports.FileSystemInboundAttachmentStore = FileSystemInboundAttachmentStore;
+function sanitizeInboundFilePart(value, fallback) {
+    return String(value || fallback)
+        .replace(/[^a-zA-Z0-9._-]/g, '_')
+        .slice(0, 240) || fallback;
+}
+function resolveInboundAttachmentUri(input) {
+    if (!input.sandboxEnabled) {
+        return (0, node_url_1.pathToFileURL)(input.filePath).href;
+    }
+    const workspacePath = String(input.workspacePath || '').trim();
+    if (!workspacePath) {
+        return undefined;
+    }
+    const relativePath = (0, node_path_1.relative)((0, node_path_1.resolve)(workspacePath), (0, node_path_1.resolve)(input.filePath));
+    if (!relativePath || relativePath.startsWith('..') || (0, node_path_1.isAbsolute)(relativePath)) {
+        return relativePath === ''
+            ? new URL(node_path_1.posix.resolve(input.sandboxWorkspacePath || '/workspace'), 'file:///').href
+            : undefined;
+    }
+    const sandboxRelativePath = relativePath.split(node_path_1.sep).join('/');
+    return new URL(node_path_1.posix.resolve(input.sandboxWorkspacePath || '/workspace', sandboxRelativePath), 'file:///').href;
+}

package/dist-electron/services/local-ai-core/src/channel/shared/inbound-authorization.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInboundChannelAuthorization = resolveInboundChannelAuthorization;
+const node_crypto_1 = require("node:crypto");
+const DEFAULT_PAIRING_EXPIRY_MS = 10 * 60 * 1000;
+function resolveInboundChannelAuthorization(input) {
+    const { store, identity } = input;
+    store.expirePendingPairings();
+    let authorized = store.getAuthorizedUser(identity.workspaceId, identity.platformUserId, identity.platformKey);
+    let autoApproved = false;
+    if (!authorized && input.autoApprove) {
+        const authorizedAt = (input.now?.() || new Date()).toISOString();
+        store.createAuthorizedUser({
+            id: `${input.authorizedUserIdPrefix}-${(0, node_crypto_1.randomUUID)()}`,
+            workspace_id: identity.workspaceId,
+            platform: identity.platformKey,
+            platform_user_id: identity.platformUserId,
+            chat_id: identity.chatId,
+            display_name: identity.displayName,
+            thread_id: null,
+            authorized_at: authorizedAt,
+        });
+        authorized = store.getAuthorizedUser(identity.workspaceId, identity.platformUserId, identity.platformKey);
+        autoApproved = Boolean(authorized);
+        if (autoApproved) {
+            input.onStateChanged?.();
+        }
+    }
+    if (authorized) {
+        return { status: 'authorized', authorized, autoApproved };
+    }
+    const existingPending = store.listPendingPairings(identity.workspaceId).find((item) => item.platform === identity.platformKey &&
+        item.platform_user_id === identity.platformUserId &&
+        item.chat_id === identity.chatId &&
+        item.status === 'pending');
+    if (existingPending) {
+        return { status: 'pending', pairingCode: existingPending.code };
+    }
+    const now = input.now?.() || new Date();
+    const pairingCode = input.generatePairingCode();
+    store.createPairingRequest({
+        code: pairingCode,
+        workspace_id: identity.workspaceId,
+        platform: identity.platformKey,
+        platform_user_id: identity.platformUserId,
+        chat_id: identity.chatId,
+        display_name: identity.displayName,
+        requested_at: now.toISOString(),
+        expires_at: new Date(now.getTime() + (input.pairingExpiryMs || DEFAULT_PAIRING_EXPIRY_MS)).toISOString(),
+        status: 'pending',
+    });
+    input.onStateChanged?.();
+    return { status: 'pending', pairingCode };
+}

package/dist-electron/services/local-ai-core/src/channel/weixin/config.js

@@ -15,7 +15,7 @@ exports.saveWeixinBuf = saveWeixinBuf;
 exports.collectWeixinWorkspaceBindings = collectWeixinWorkspaceBindings;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const desktop_js_1 = require("../../../../../shared/desktop.js");
+const superai_contracts_1 = require("../../../../../packages/contracts/src/index.js");
 const channel_keys_js_1 = require("../shared/channel-keys.js");
 exports.DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
 exports.DEFAULT_CDN_BASE_URL = 'https://novac2c.cdn.weixin.qq.com/c2c';
@@ -75,7 +75,7 @@ function collectWeixinWorkspaceBindings(config) {
         const platforms = Array.isArray(project.platforms) ? project.platforms : [];
         return platforms
             .map((platform) => ({
-            platformType: (0, desktop_js_1.normalizeDesktopPlatformType)(platform?.type),
+            platformType: (0, superai_contracts_1.normalizeDesktopPlatformType)(platform?.type),
             options: platform?.options && typeof platform.options === 'object'
                 ? platform.options
                 : {},

package/dist-electron/services/local-ai-core/src/channel/weixin/inbound-media.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWeixinAttachmentContentPart = createWeixinAttachmentContentPart;
+function createWeixinAttachmentContentPart(att) {
+    if (att.kind === 'image') {
+        if (!att.data)
+            return null;
+        return {
+            type: 'image',
+            data: att.data,
+            ...(att.uri ? { uri: att.uri } : {}),
+            mimeType: att.mimeType,
+            fileName: att.name,
+        };
+    }
+    return {
+        type: 'file',
+        path: att.path,
+        fileName: att.name,
+    };
+}

package/dist-electron/services/local-ai-core/src/channel/weixin/inbound-poller.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWeixinInboundPoller = runWeixinInboundPoller;
+const node_path_1 = require("node:path");
+const local_core_errors_js_1 = require("../../kernel/local-core-errors.js");
+const config_js_1 = require("./config.js");
+const transport_js_1 = require("./transport.js");
+const text_utils_js_1 = require("./text-utils.js");
+const inbound_media_js_1 = require("./inbound-media.js");
+const RETRY_DELAY_MS = 2_000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const ERROR_LOG_WINDOW_MS = 5 * 60 * 1000;
+function computeRetryDelay(failures) {
+    if (failures <= 1)
+        return RETRY_DELAY_MS;
+    if (failures === 2)
+        return 5_000;
+    if (failures === 3)
+        return 15_000;
+    if (failures === 4)
+        return 30_000;
+    return 60_000;
+}
+async function runWeixinInboundPoller(input) {
+    const { binding, signal } = input;
+    const errorLogWindows = new Map();
+    let buf = (0, config_js_1.loadWeixinBuf)(binding);
+    let consecutiveFailures = 0;
+    const logPollError = (errorKey, message) => {
+        const key = `${binding.workspaceId}:${binding.instanceId}`;
+        const now = Date.now();
+        const current = errorLogWindows.get(key);
+        if (!current || current.errorKey !== errorKey || now - current.at >= ERROR_LOG_WINDOW_MS) {
+            input.log?.(current?.count && current.count > 1 ? `${message} (repeated ${current.count} times)` : message);
+            errorLogWindows.set(key, { at: now, count: 1, errorKey });
+            return;
+        }
+        current.count += 1;
+        errorLogWindows.set(key, current);
+    };
+    while (!signal.aborted) {
+        try {
+            const resp = await (0, transport_js_1.getWeixinUpdates)(binding, buf, signal);
+            const isApiError = (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
+            if (isApiError) {
+                consecutiveFailures += 1;
+                const state = input.getRuntimeState();
+                const retryDelayMs = computeRetryDelay(consecutiveFailures);
+                if (resp.errcode === -14 || resp.ret === -14) {
+                    if (state) {
+                        state.status = 'error';
+                        state.connected = false;
+                        state.consecutiveFailures = consecutiveFailures;
+                        state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
+                        input.setRuntimeError(state, (0, local_core_errors_js_1.toLocalCoreErrorInfo)(new local_core_errors_js_1.LocalCoreError('channel_session_expired', 'WeChat login expired.')));
+                        input.notifyRuntimeStateChanged();
+                    }
+                }
+                logPollError(`ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg || ''}`, `localcore-weixin getUpdates failed for ${binding.workspaceId}: ret=${resp.ret} errcode=${resp.errcode}${resp.errmsg ? ` errmsg=${resp.errmsg}` : ''} (${consecutiveFailures})`);
+                if (state && resp.errcode !== -14 && resp.ret !== -14) {
+                    state.consecutiveFailures = consecutiveFailures;
+                    state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
+                }
+                await (0, text_utils_js_1.waitForWeixinRetry)(retryDelayMs, signal);
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                    consecutiveFailures = MAX_CONSECUTIVE_FAILURES;
+                }
+                continue;
+            }
+            consecutiveFailures = 0;
+            const state = input.getRuntimeState();
+            if (state) {
+                input.clearRuntimeError(state);
+                state.status = 'running';
+                state.connected = true;
+                input.notifyRuntimeStateChanged();
+            }
+            if (resp.get_updates_buf) {
+                buf = resp.get_updates_buf;
+                (0, config_js_1.saveWeixinBuf)(binding, buf);
+            }
+            for (const msg of resp.msgs ?? []) {
+                const items = msg.item_list ?? [];
+                const textItem = items.find((item) => item.type === transport_js_1.TEXT_ITEM_TYPE);
+                const voiceTextItems = items.filter((item) => item.type === transport_js_1.VOICE_ITEM_TYPE && item.voice_item?.text);
+                const mediaItems = items.filter((item) => item.type === transport_js_1.IMAGE_ITEM_TYPE || item.type === transport_js_1.FILE_ITEM_TYPE);
+                if (!textItem && voiceTextItems.length === 0 && mediaItems.length === 0)
+                    continue;
+                const conversationId = msg.from_user_id ?? '';
+                const text = [textItem?.text_item?.text?.trim(), ...voiceTextItems.map((item) => item.voice_item?.text?.trim())]
+                    .filter((part) => Boolean(part))
+                    .join('\n\n');
+                const msgId = msg.msg_id ?? String(Date.now());
+                let attachmentText = '';
+                const attachmentParts = [];
+                if (mediaItems.length > 0) {
+                    const uploadsDir = (0, node_path_1.join)(binding.stateDir, 'weixin-uploads');
+                    const mayMaterializeAttachments = binding.allowFrom === '*' || Boolean(input.getAuthorizedUser(binding.workspaceId, conversationId, binding.platformKey));
+                    if (!mayMaterializeAttachments) {
+                        for (const item of mediaItems) {
+                            const itemData = item.image_item ?? item.file_item ?? null;
+                            const declaredName = String(itemData?.file_name ?? (item.type === transport_js_1.IMAGE_ITEM_TYPE ? 'image' : 'file'));
+                            attachmentText += attachmentText ? '\n' : '';
+                            attachmentText += item.type === transport_js_1.IMAGE_ITEM_TYPE ? '[Image]' : `[File: ${declaredName}]`;
+                        }
+                    }
+                    else {
+                        const downloads = await Promise.all(mediaItems.map(async (item, index) => {
+                            try {
+                                return await input.downloadMediaItem(item, msgId, index, uploadsDir, binding);
+                            }
+                            catch (error) {
+                                input.log?.(`localcore-weixin attachment download failed (${conversationId}#${index}): ${(0, text_utils_js_1.formatWeixinError)(error)}`);
+                                return null;
+                            }
+                        }));
+                        for (const attachment of downloads) {
+                            if (!attachment) {
+                                continue;
+                            }
+                            attachmentText += attachmentText ? '\n' : '';
+                            attachmentText += attachment.kind === 'image'
+                                ? `[Image: ${attachment.path}]`
+                                : `[File "${attachment.name}": ${attachment.path}]`;
+                            const part = (0, inbound_media_js_1.createWeixinAttachmentContentPart)(attachment);
+                            if (part)
+                                attachmentParts.push(part);
+                        }
+                    }
+                }
+                const fullText = [text, attachmentText].filter(Boolean).join('\n\n');
+                if (!fullText)
+                    continue;
+                await input.handleInboundMessage({
+                    workspaceId: binding.workspaceId,
+                    instanceId: binding.instanceId,
+                    platformKey: binding.platformKey,
+                    platformUserId: conversationId,
+                    chatId: conversationId,
+                    displayName: conversationId.slice(-6),
+                    text: fullText,
+                    messageId: msgId,
+                    contextToken: msg.context_token,
+                    contentParts: [
+                        ...(text ? [{ type: 'text', text }] : []),
+                        ...attachmentParts,
+                    ],
+                });
+            }
+        }
+        catch (error) {
+            if (signal.aborted)
+                return;
+            consecutiveFailures += 1;
+            const retryDelayMs = computeRetryDelay(consecutiveFailures);
+            const state = input.getRuntimeState();
+            if (state) {
+                state.consecutiveFailures = consecutiveFailures;
+                state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
+                input.setRuntimeError(state, (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error));
+                input.notifyRuntimeStateChanged();
+            }
+            logPollError((0, text_utils_js_1.formatWeixinError)(error), `localcore-weixin getUpdates error for ${binding.workspaceId} (${consecutiveFailures}): ${(0, text_utils_js_1.formatWeixinError)(error)}`);
+            await (0, text_utils_js_1.waitForWeixinRetry)(retryDelayMs, signal);
+        }
+    }
+}