@kafca/agentdock 0.1.42 → 0.1.43

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

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildInteractiveCard = buildInteractiveCard;
 exports.renderPermissionCard = renderPermissionCard;
 exports.renderPendingPairingCard = renderPendingPairingCard;
+exports.buildSessionCommandCard = buildSessionCommandCard;
 exports.extractCardActionMessageId = extractCardActionMessageId;
 exports.extractCardActionValue = extractCardActionValue;
+exports.extractSessionCommandActionValue = extractSessionCommandActionValue;
 exports.formatPermissionButtonLabel = formatPermissionButtonLabel;
 exports.formatPermissionResponseLabel = formatPermissionResponseLabel;
 const desktop_js_1 = require("../../../../../shared/desktop.js");
@@ -80,6 +82,37 @@ function renderPendingPairingCard(code) {
     }
     return lines.join('\n\n');
 }
+function buildSessionCommandCard(text, actionRows = [], sessionKey, threadId) {
+    const elements = [];
+    if (text) {
+        elements.push({ tag: 'markdown', content: text });
+    }
+    for (const row of actionRows) {
+        const actions = row
+            .filter((button) => button.label && button.command)
+            .map((button) => ({
+            tag: 'button',
+            text: {
+                tag: 'plain_text',
+                content: button.label,
+            },
+            type: button.type || 'default',
+            value: {
+                action: 'session_command',
+                command: button.command,
+                session_key: sessionKey || '',
+                thread_id: threadId || '',
+            },
+        }));
+        if (actions.length) {
+            elements.push({ tag: 'action', actions });
+        }
+    }
+    return {
+        config: { wide_screen_mode: true },
+        elements,
+    };
+}
 function extractCardActionMessageId(...payloads) {
     for (const payload of payloads) {
         const messageId = extractKnownCardActionMessageId(payload);
@@ -117,6 +150,28 @@ function extractCardActionValue(payload) {
         sessionKey,
     };
 }
+function extractSessionCommandActionValue(payload) {
+    const event = (payload?.event && typeof payload.event === 'object')
+        ? payload.event
+        : payload;
+    const value = event?.action?.value;
+    if (!value || value.action !== 'session_command') {
+        return null;
+    }
+    const command = String(value.command || '').trim();
+    const threadId = String(value.thread_id || '').trim();
+    const sessionKey = String(value.session_key || '').trim();
+    if (!command || !threadId) {
+        return null;
+    }
+    return {
+        event,
+        value: value,
+        command,
+        threadId,
+        sessionKey,
+    };
+}
 function formatPermissionButtonLabel(button) {
     return formatPermissionResponseLabel(button.data || button.text);
 }

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

@@ -41,11 +41,13 @@ const node_path_1 = require("node:path");
 const desktop_js_1 = require("../../../../../shared/desktop.js");
 const content_js_1 = require("../shared/content.js");
 const file_utils_js_1 = require("../shared/file-utils.js");
+const session_command_runtime_js_1 = require("../shared/session-command-runtime.js");
 const cards_js_1 = require("./cards.js");
 const config_js_1 = require("./config.js");
 const registration_js_1 = require("./registration.js");
 const messages_js_1 = require("./rendering/messages.js");
 const runtime_state_js_1 = require("./runtime-state.js");
+const session_command_service_js_1 = require("../../thread/session-command-service.js");
 const PAIRING_EXPIRY_MS = 10 * 60 * 1000;
 const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
 const LARK_FINAL_PATCH_INTERVAL_MS = 900;
@@ -62,12 +64,37 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
     outboundEventChains = new Map();
     outboundTurns = new Map();
     mutedThreadBridgeCounts = new Map();
+    sessionCommandRuntime;
     larkModulePromise = null;
     platform = 'lark';
     routeType = 'channel.chat';
     constructor(options) {
         super();
         this.options = options;
+        const sessionCommandService = new session_command_service_js_1.SessionCommandService({
+            listThreads: (workspaceId) => this.options.getWorkspaceRouter().listThreads(workspaceId),
+            getThread: (threadId) => this.options.getWorkspaceRouter().getThread(threadId),
+            createThread: (workspaceId, title) => this.options.getWorkspaceRouter().createThread(workspaceId, title),
+            renameThread: (threadId, title) => this.options.getWorkspaceRouter().renameThread(threadId, title),
+            deleteThread: (threadId) => this.options.getWorkspaceRouter().deleteThread(threadId),
+        });
+        this.sessionCommandRuntime = new session_command_runtime_js_1.ChannelSessionCommandRuntime({
+            service: sessionCommandService,
+            store: this.options.store,
+            getThreadSessionKey: (threadId) => this.options.getWorkspaceRouter().getThreadSessionKey(threadId),
+            setThreadRoute: (sessionKey, route) => {
+                this.threadRouting.set(sessionKey, route);
+            },
+            createRoute: (input, threadId) => ({
+                workspaceId: input.workspaceId,
+                instanceId: input.instanceId,
+                platformKey: input.platformKey,
+                platformUserId: input.platformUserId,
+                chatId: input.chatId,
+                threadId,
+            }),
+            sendResult: (input, result) => this.sendSessionCommandResult(input, result),
+        });
     }
     async refreshBindings() {
         const config = await this.options.readConfig();
@@ -204,6 +231,17 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             }
         };
     }
+    async executeSessionCommand(input) {
+        return this.sessionCommandRuntime.execute(input);
+    }
+    async sendSessionCommandResult(input, result) {
+        const state = this.resolveRuntimeState(input.workspaceId, input.instanceId).state;
+        if (state?.client && state.connected && result.card?.actions?.length && state.cardActionsEnabled) {
+            await this.sendSessionCommandCard(state, input.chatId, result.displayText, result.card.actions, this.options.getWorkspaceRouter().getThreadSessionKey(input.currentThreadId), input.currentThreadId);
+            return;
+        }
+        await this.sendImmediateCard(input.workspaceId, input.chatId, result.displayText, input.instanceId);
+    }
     async sendOutboundMessage(workspaceId, input) {
         const state = this.resolveRuntimeState(workspaceId, input.route?.instanceId).state;
         if (!state?.client || !state.connected) {
@@ -659,35 +697,18 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const acknowledgement = this.createTurnState(effectiveSessionKey, input.messageId);
         await this.addAcknowledgementReaction(input.workspaceId, input.messageId, acknowledgement, instanceId);
         const slashCommand = this.parseSlashCommand(input.text);
-        if (slashCommand?.name === 'new') {
-            const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`;
-            const nextThread = await router.createThread(input.workspaceId, title);
-            const inheritedMode = this.options.store.getThreadRow?.(threadId)?.agent_mode || '';
-            if (inheritedMode && inheritedMode !== 'default') {
-                this.options.store.updateThreadAgentMode?.(nextThread.id, inheritedMode);
-            }
-            const now = new Date().toISOString();
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, platformKey);
-            this.options.store.upsertPlatformThreadBinding({
-                workspace_id: input.workspaceId,
-                platform: platformKey,
-                chat_id: input.chatId,
-                platform_user_id: input.platformUserId,
-                thread_id: nextThread.id,
-                last_platform_message_id: null,
-                created_at: now,
-                updated_at: now,
-            });
-            this.threadRouting.set(this.options.getWorkspaceRouter().getThreadSessionKey(nextThread.id), {
-                workspaceId: input.workspaceId,
-                instanceId,
-                platformKey,
-                platformUserId: input.platformUserId,
-                chatId: input.chatId,
-                threadId: nextThread.id,
-            });
-            await this.sendImmediateCard(input.workspaceId, input.chatId, '**已开始新会话**', instanceId);
-            return { paired: true, threadId: nextThread.id };
+        const sessionCommand = await this.executeSessionCommand({
+            workspaceId: input.workspaceId,
+            currentThreadId: threadId,
+            text: input.text,
+            defaultTitle: `${input.displayName || 'Lark'} ${new Date().toLocaleTimeString()}`,
+            chatId: input.chatId,
+            platformUserId: input.platformUserId,
+            platformKey,
+            instanceId,
+        });
+        if (sessionCommand.handled) {
+            return { paired: true, threadId: sessionCommand.threadId || threadId };
         }
         const latestRun = this.options.store.getLatestRunForThread(threadId);
         if ((normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny')
@@ -1157,6 +1178,21 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         this.options.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: this.resolveReceiveIdType(chatId),
+            },
+            data: {
+                receive_id: chatId,
+                msg_type: 'interactive',
+                content: JSON.stringify((0, cards_js_1.buildSessionCommandCard)(text, actionRows, sessionKey, threadId)),
+            },
+        });
+        this.options.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);
@@ -1272,6 +1308,27 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const instanceId = legacyCall ? 'default' : instanceIdOrData;
         const data = (legacyCall ? instanceIdOrData : maybeData) || {};
         try {
+            const sessionAction = (0, cards_js_1.extractSessionCommandActionValue)(data);
+            if (sessionAction) {
+                const route = this.threadRouting.get(sessionAction.sessionKey)
+                    || this.routeFromThreadBinding(sessionAction.threadId, instanceId);
+                if (!route) {
+                    this.options.log?.(`localcore-lark session card action ignored without route for thread=${sessionAction.threadId}`);
+                    return;
+                }
+                await this.executeSessionCommand({
+                    workspaceId,
+                    currentThreadId: sessionAction.threadId,
+                    text: sessionAction.command,
+                    defaultTitle: `Lark ${new Date().toLocaleTimeString()}`,
+                    chatId: route.chatId,
+                    platformUserId: route.platformUserId,
+                    platformKey: route.platformKey,
+                    instanceId: route.instanceId,
+                });
+                this.options.log?.(`localcore-lark processed session card action for ${workspaceId}/${instanceId}: ${sessionAction.command}`);
+                return;
+            }
             const action = (0, cards_js_1.extractCardActionValue)(data);
             if (!action) {
                 return;
@@ -1285,6 +1342,21 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
             this.options.log?.(`localcore-lark card action failed for ${workspaceId}/${instanceId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    routeFromThreadBinding(threadId, instanceId) {
+        const binding = this.options.store.getPlatformThreadBindingByThreadId(threadId);
+        if (!binding || (binding.platform !== 'lark' && !binding.platform.startsWith('lark:'))) {
+            return undefined;
+        }
+        const bindingInstanceId = getLarkInstanceId(binding.platform) || instanceId || 'default';
+        return {
+            workspaceId: binding.workspace_id,
+            instanceId: bindingInstanceId,
+            platformKey: binding.platform,
+            platformUserId: binding.platform_user_id,
+            chatId: binding.chat_id,
+            threadId: binding.thread_id,
+        };
+    }
     async markPermissionCardActionHandled(workspaceId, instanceId, rootPayload, payload, value, response, threadId) {
         const state = this.resolveRuntimeState(workspaceId, instanceId).state;
         if (!state?.client) {

package/dist-electron/services/local-ai-core/src/channel/shared/session-command-runtime.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelSessionCommandRuntime = void 0;
+class ChannelSessionCommandRuntime {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async execute(input) {
+        const result = await this.options.service.execute(input.text, {
+            workspaceId: input.workspaceId,
+            currentThreadId: input.currentThreadId,
+            defaultTitle: input.defaultTitle,
+        });
+        if (!result.handled) {
+            return { handled: false, threadId: input.currentThreadId };
+        }
+        let activeThreadId = input.currentThreadId;
+        for (const effect of result.effects || []) {
+            if (effect.type === 'created_thread') {
+                this.inheritAgentMode(input.currentThreadId, effect.threadId);
+            }
+            if (effect.type === 'activate_thread') {
+                activeThreadId = effect.threadId;
+                this.activateThread(input, effect.threadId);
+            }
+        }
+        await this.options.sendResult(input, result);
+        return { handled: true, threadId: activeThreadId, result };
+    }
+    inheritAgentMode(sourceThreadId, targetThreadId) {
+        const inheritedMode = this.options.store.getThreadRow?.(sourceThreadId)?.agent_mode || '';
+        if (inheritedMode && inheritedMode !== 'default') {
+            this.options.store.updateThreadAgentMode?.(targetThreadId, inheritedMode);
+        }
+    }
+    activateThread(input, threadId) {
+        const now = new Date().toISOString();
+        this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, threadId, input.platformKey);
+        this.options.store.upsertPlatformThreadBinding({
+            workspace_id: input.workspaceId,
+            platform: input.platformKey,
+            chat_id: input.chatId,
+            platform_user_id: input.platformUserId,
+            thread_id: threadId,
+            last_platform_message_id: null,
+            created_at: now,
+            updated_at: now,
+        });
+        this.options.setThreadRoute(this.options.getThreadSessionKey(threadId), this.options.createRoute(input, threadId));
+    }
+}
+exports.ChannelSessionCommandRuntime = ChannelSessionCommandRuntime;

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

@@ -13,6 +13,8 @@ const node_crypto_2 = require("node:crypto");
 const desktop_js_1 = require("../../../../../shared/desktop.js");
 const content_js_1 = require("../shared/content.js");
 const file_utils_js_1 = require("../shared/file-utils.js");
+const session_command_runtime_js_1 = require("../shared/session-command-runtime.js");
+const session_command_service_js_1 = require("../../thread/session-command-service.js");
 const config_js_1 = require("./config.js");
 const transport_js_1 = require("./transport.js");
 // ==================== Constants ====================
@@ -150,11 +152,36 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
     outboundTurns = new Map();
     processedInboundMessages = new Map();
     mutedThreadBridgeCounts = new Map();
+    sessionCommandRuntime;
     platform = 'weixin';
     routeType = 'channel.chat';
     constructor(options) {
         super();
         this.options = options;
+        const sessionCommandService = new session_command_service_js_1.SessionCommandService({
+            listThreads: (workspaceId) => this.options.getWorkspaceRouter().listThreads(workspaceId),
+            getThread: (threadId) => this.options.getWorkspaceRouter().getThread(threadId),
+            createThread: (workspaceId, title) => this.options.getWorkspaceRouter().createThread(workspaceId, title),
+            renameThread: (threadId, title) => this.options.getWorkspaceRouter().renameThread(threadId, title),
+            deleteThread: (threadId) => this.options.getWorkspaceRouter().deleteThread(threadId),
+        });
+        this.sessionCommandRuntime = new session_command_runtime_js_1.ChannelSessionCommandRuntime({
+            service: sessionCommandService,
+            store: this.options.store,
+            getThreadSessionKey: (threadId) => this.options.getWorkspaceRouter().getThreadSessionKey(threadId),
+            setThreadRoute: (sessionKey, route) => {
+                this.threadRouting.set(sessionKey, route);
+            },
+            createRoute: (input, threadId) => ({
+                workspaceId: input.workspaceId,
+                instanceId: input.instanceId,
+                platformKey: input.platformKey,
+                platformUserId: input.platformUserId,
+                chatId: input.chatId,
+                threadId,
+            }),
+            sendResult: (input, result) => this.sendSessionCommandResult(input, result),
+        });
     }
     // ==================== Lifecycle ====================
     async refreshBindings() {
@@ -648,7 +675,6 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
                 updated_at: now,
             });
         }
-        const sessionKey = router.getThreadSessionKey(threadId);
         const normalizedText = String(input.text || '').trim().toLowerCase();
         const permissionThreadId = (normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny') ? this.findAwaitingPermissionThreadId(input.workspaceId, input.chatId, input.platformUserId, input.platformKey) : '';
         if (permissionThreadId && permissionThreadId !== threadId) {
@@ -665,38 +691,19 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         });
         // Handle slash commands
         const slashCommand = this.parseSlashCommand(input.text);
-        if (slashCommand?.name === 'new') {
-            const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'WeChat'} ${new Date().toLocaleTimeString()}`;
-            const nextThread = await router.createThread(input.workspaceId, title);
-            const inheritedMode = this.options.store.getThreadRow?.(threadId)?.agent_mode || '';
-            if (inheritedMode && inheritedMode !== 'default') {
-                this.options.store.updateThreadAgentMode?.(nextThread.id, inheritedMode);
-            }
-            const now = new Date().toISOString();
-            this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, platformKey);
-            this.options.store.upsertPlatformThreadBinding({
-                workspace_id: input.workspaceId,
-                platform: platformKey,
-                chat_id: input.chatId,
-                platform_user_id: input.platformUserId,
-                thread_id: nextThread.id,
-                last_platform_message_id: null,
-                created_at: now,
-                updated_at: now,
-            });
-            this.threadRouting.set(router.getThreadSessionKey(nextThread.id), {
-                workspaceId: input.workspaceId,
-                instanceId,
-                platformKey,
-                platformUserId: input.platformUserId,
-                chatId: input.chatId,
-                threadId: nextThread.id,
-            });
-            const st = this.runtime.get((0, config_js_1.runtimeKey)(input.workspaceId, instanceId));
-            if (st?.connected) {
-                await this.sendTextMessage(st, input.chatId, '**已开始新会话**', input.contextToken);
-            }
-            return { paired: true, threadId: nextThread.id };
+        const sessionCommand = await this.executeSessionCommand({
+            workspaceId: input.workspaceId,
+            currentThreadId: threadId,
+            text: input.text,
+            defaultTitle: `${input.displayName || 'WeChat'} ${new Date().toLocaleTimeString()}`,
+            chatId: input.chatId,
+            platformUserId: input.platformUserId,
+            platformKey,
+            instanceId,
+            contextToken: input.contextToken,
+        });
+        if (sessionCommand.handled) {
+            return { paired: true, threadId: sessionCommand.threadId || threadId };
         }
         const latestRun = this.options.store.getLatestRunForThread(threadId);
         if ((normalizedText === 'allow' || normalizedText === 'allow all' || normalizedText === 'deny')
@@ -711,6 +718,17 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(wrappedText, input.contentParts));
         return { paired: true, threadId };
     }
+    async executeSessionCommand(input) {
+        return this.sessionCommandRuntime.execute(input);
+    }
+    async sendSessionCommandResult(input, result) {
+        const state = this.resolveRuntimeState(input.workspaceId, input.instanceId).state;
+        if (!state?.connected) {
+            this.options.log?.(`localcore-weixin session command response skipped: workspace not connected: ${input.workspaceId}`);
+            return;
+        }
+        await this.sendTextMessage(state, input.chatId, result.displayText, input.contextToken);
+    }
     // ==================== Private: Bindings ====================
     resolveRuntimeState(workspaceId, instanceId) {
         if (instanceId) {