@kafca/agentdock 0.1.46 → 0.1.48

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

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseChannelGateway = void 0;
+const node_events_1 = require("node:events");
+const node_crypto_1 = require("node:crypto");
+const session_command_runtime_js_1 = require("../shared/session-command-runtime.js");
+const thread_slash_command_dispatcher_js_1 = require("../../thread/thread-slash-command-dispatcher.js");
+function resolveRuntimeKey(workspaceId, instanceId) {
+    return instanceId ? `${workspaceId}::${instanceId}` : workspaceId;
+}
+class BaseChannelGateway extends node_events_1.EventEmitter {
+    options;
+    routeType = 'channel.chat';
+    runtime = new Map();
+    threadRouting = new Map();
+    outboundEventChains = new Map();
+    outboundTurns = new Map();
+    mutedThreadBridgeCounts = new Map();
+    sessionCommandRuntime;
+    constructor(options) {
+        super();
+        this.options = options;
+        const slashCommands = new thread_slash_command_dispatcher_js_1.ThreadSlashCommandDispatcher({
+            session: {
+                listThreads: (workspaceId) => options.getWorkspaceRouter().listThreads(workspaceId),
+                getThread: (threadId) => options.getWorkspaceRouter().getThread(threadId),
+                createThread: (workspaceId, title) => options.getWorkspaceRouter().createThread(workspaceId, title),
+                renameThread: (threadId, title) => options.getWorkspaceRouter().renameThread(threadId, title),
+                deleteThread: (threadId) => options.getWorkspaceRouter().deleteThread(threadId),
+            },
+            thread: {
+                getThreadRow: (threadId) => options.store.getThreadRow(threadId),
+                updateThreadAgentMode: (threadId, mode) => options.store.updateThreadAgentMode(threadId, mode),
+                updateThreadAgentType: (threadId, agentType) => options.store.updateThreadAgentType(threadId, agentType),
+                getLatestRunForThread: (threadId) => options.store.getLatestRunForThread(threadId),
+                createAuditEvent: (input) => options.store.createAuditEvent(input),
+                getAgentTypes: () => options.getWorkspaceRouter().getAgentTypes(),
+                setThreadMode: async (threadId, mode) => {
+                    await options.getWorkspaceRouter().setThreadMode(threadId, mode);
+                },
+                closeThreadSession: (threadId) => options.getWorkspaceRouter().closeThreadSession(threadId),
+                interruptRun: (runId) => options.getWorkspaceRouter().interruptRun(runId),
+                setChannelPreferredAgent: (input) => options.store.updatePlatformThreadPreferredAgent(input.workspaceId, input.chatId, input.platformUserId, input.agentType, input.platform),
+                log: options.log,
+            },
+        });
+        this.sessionCommandRuntime = new session_command_runtime_js_1.ChannelSessionCommandRuntime({
+            dispatcher: slashCommands,
+            store: options.store,
+            getThreadSessionKey: (threadId) => options.getWorkspaceRouter().getThreadSessionKey(threadId),
+            setThreadRoute: (sessionKey, route) => {
+                this.threadRouting.set(sessionKey, route);
+            },
+            createRoute: (input, threadId) => this.makeThreadRoute(input, threadId),
+            sendResult: (input, result) => this.sendSessionCommandResult(input, result),
+        });
+    }
+    // ==================== Lifecycle ====================
+    async refreshBindings() {
+        const config = await this.options.readConfig();
+        const bindings = this.collectBindings(config);
+        const nextKeys = new Set(bindings.map((b) => resolveRuntimeKey(b.workspaceId, b.instanceId)));
+        for (const key of [...this.runtime.keys()]) {
+            if (!nextKeys.has(key)) {
+                await this.stopWorkspaceKey(key);
+            }
+        }
+        for (const binding of bindings) {
+            const key = resolveRuntimeKey(binding.workspaceId, binding.instanceId);
+            const current = this.runtime.get(key);
+            if (!binding.enabled) {
+                if (current) {
+                    await this.stopWorkspaceKey(key);
+                }
+                else {
+                    this.runtime.set(key, this.createDisabledState(binding));
+                }
+                continue;
+            }
+            if (current?.status === 'running' && this.isSameIdentity(current, binding)) {
+                continue;
+            }
+            await this.startWorkspace(binding);
+        }
+        this.notifyRuntimeStateChanged();
+    }
+    /** Returns true if the current runtime state belongs to the same identity as the binding (skip restart). */
+    isSameIdentity(_state, _binding) {
+        return false;
+    }
+    async enable(workspaceId, instanceId) {
+        const binding = await this.getBinding(workspaceId, instanceId);
+        await this.startWorkspace(binding);
+        return this.getStatus(workspaceId, binding.instanceId);
+    }
+    async disable(workspaceId, instanceId) {
+        await this.stopWorkspace(workspaceId, instanceId);
+        return this.getStatus(workspaceId, instanceId);
+    }
+    async start() {
+        await this.refreshBindings();
+    }
+    async stop() {
+        await this.close();
+    }
+    close() {
+        return Promise.all([...this.runtime.keys()].map((key) => this.stopWorkspaceKey(key))).then(() => undefined);
+    }
+    // ==================== Status ====================
+    getStatus(workspaceId, instanceId) {
+        this.options.store.expirePendingPairings();
+        const resolved = this.resolveRuntimeState(workspaceId, instanceId);
+        return this.buildStatusObject(resolved.state, resolved);
+    }
+    listStatuses() {
+        return [...this.runtime.values()]
+            .sort((a, b) => `${a.workspaceId}:${a.instanceId}`.localeCompare(`${b.workspaceId}:${b.instanceId}`))
+            .map((state) => this.getStatus(state.workspaceId, state.instanceId));
+    }
+    listPendingPairings(workspaceId) {
+        this.options.store.expirePendingPairings();
+        return this.options.store
+            .listPairingRequests(workspaceId)
+            .filter((item) => item.platform === this.platform || item.platform.startsWith(`${this.platform}:`))
+            .filter((item) => item.status === 'pending' && item.expiresAt >= new Date().toISOString());
+    }
+    listAuthorizedUsers(workspaceId) {
+        return this.options.store.listAuthorizedUsers(workspaceId)
+            .filter((item) => item.platform === this.platform || item.platform.startsWith(`${this.platform}:`));
+    }
+    // ==================== Pairing ====================
+    approvePairing(code) {
+        this.options.store.expirePendingPairings();
+        const pairing = this.options.store.getPairingRequest(code);
+        if (!pairing)
+            throw new Error(`Pairing code not found: ${code}`);
+        if (pairing.platform !== this.platform && !pairing.platform.startsWith(`${this.platform}:`))
+            throw new Error(`Pairing code ${code} is not a ${this.platform} pairing`);
+        if (pairing.status !== 'pending')
+            throw new Error(`Pairing code ${code} is already ${pairing.status}`);
+        if (pairing.expires_at < new Date().toISOString()) {
+            this.options.store.updatePairingStatus(code, 'expired');
+            throw new Error(`Pairing code ${code} has expired`);
+        }
+        const existing = this.options.store.getAuthorizedUser(pairing.workspace_id, pairing.platform_user_id, pairing.platform);
+        const userId = existing?.id || `${this.platform}-user-${(0, node_crypto_1.randomUUID)()}`;
+        const authorizedAt = new Date().toISOString();
+        this.options.store.createAuthorizedUser({
+            id: userId,
+            workspace_id: pairing.workspace_id,
+            platform: pairing.platform,
+            platform_user_id: pairing.platform_user_id,
+            chat_id: pairing.chat_id,
+            display_name: pairing.display_name,
+            thread_id: existing?.thread_id || null,
+            authorized_at: authorizedAt,
+        });
+        this.options.store.updatePairingStatus(code, 'approved');
+        this.notifyRuntimeStateChanged();
+        const user = this.options.store.listAuthorizedUsers(pairing.workspace_id, pairing.platform).find((e) => e.id === userId);
+        if (!user)
+            throw new Error('Authorized user lookup failed after approval');
+        return user;
+    }
+    rejectPairing(code) {
+        const pairing = this.options.store.getPairingRequest(code);
+        if (!pairing)
+            throw new Error(`Pairing code not found: ${code}`);
+        if (pairing.platform !== this.platform && !pairing.platform.startsWith(`${this.platform}:`))
+            throw new Error(`Pairing code ${code} is not a ${this.platform} pairing`);
+        this.options.store.updatePairingStatus(code, 'rejected');
+        this.notifyRuntimeStateChanged();
+        return { rejected: true };
+    }
+    // ==================== Bridge Event Throttling ====================
+    muteThreadBridge(threadId) {
+        const current = this.mutedThreadBridgeCounts.get(threadId) || 0;
+        this.mutedThreadBridgeCounts.set(threadId, current + 1);
+    }
+    unmuteThreadBridge(threadId) {
+        const current = this.mutedThreadBridgeCounts.get(threadId) || 0;
+        if (current <= 1) {
+            this.mutedThreadBridgeCounts.delete(threadId);
+            return;
+        }
+        this.mutedThreadBridgeCounts.set(threadId, current - 1);
+    }
+    // ==================== Scheduling ====================
+    async sendScheduledCard(workspaceId, chatId, text) {
+        return this.sendScheduledMessage(workspaceId, { type: 'channel.chat', channelId: chatId }, text);
+    }
+    async sendScheduledMessage(workspaceId, route, text) {
+        const state = this.resolveRuntimeState(workspaceId, route.instanceId).state;
+        if (!state?.connected) {
+            this.options.log?.(`[${this.platform}] scheduled message skipped: workspace not connected: ${workspaceId}`);
+            return '';
+        }
+        try {
+            await this.sendOutboundMessage(workspaceId, {
+                route: { type: 'channel.chat', channelId: route.channelId, participantId: route.participantId },
+                parts: [{ type: 'text', text }],
+            });
+            return `${this.platform}_sched_${(0, node_crypto_1.randomUUID)()}`;
+        }
+        catch (error) {
+            this.options.log?.(`[${this.platform}] scheduled message failed for ${workspaceId}: ${error instanceof Error ? error.message : String(error)}`);
+            return '';
+        }
+    }
+    registerScheduledThreadBridge(input) {
+        const instanceId = input.route.instanceId || 'default';
+        const route = {
+            workspaceId: input.workspaceId,
+            instanceId,
+            platformKey: `${this.platform}${instanceId !== 'default' ? `:${instanceId}` : ''}`,
+            platformUserId: input.route.participantId || '',
+            chatId: input.route.channelId,
+            threadId: input.threadId,
+        };
+        const previousRoute = this.threadRouting.get(input.sessionKey);
+        this.threadRouting.set(input.sessionKey, route);
+        return () => {
+            if (previousRoute) {
+                this.threadRouting.set(input.sessionKey, previousRoute);
+            }
+            else {
+                this.threadRouting.delete(input.sessionKey);
+            }
+        };
+    }
+    // ==================== Session Commands ====================
+    async executeSessionCommand(input) {
+        return this.sessionCommandRuntime.execute(input);
+    }
+    // ==================== Runtime Management ====================
+    resolveRuntimeState(workspaceId, instanceId) {
+        const key = resolveRuntimeKey(workspaceId, instanceId);
+        if (instanceId) {
+            const state = this.runtime.get(key) || (instanceId === 'default' ? this.runtime.get(workspaceId) : undefined);
+            return { instanceId, state };
+        }
+        const states = [...this.runtime.values()].filter((entry) => entry.workspaceId === workspaceId);
+        const state = states.find((entry) => entry.instanceId === 'default') || states[0];
+        return { instanceId: state?.instanceId || 'default', state: state || this.runtime.get(workspaceId) };
+    }
+    async getBinding(workspaceId, instanceId) {
+        const config = await this.options.readConfig();
+        const bindings = this.collectBindings(config).filter((entry) => entry.workspaceId === workspaceId);
+        const binding = instanceId
+            ? bindings.find((entry) => entry.instanceId === instanceId)
+            : bindings.find((entry) => entry.instanceId === 'default') || bindings[0];
+        if (!binding) {
+            throw new Error(`No ${this.platform} binding configured for workspace "${workspaceId}"${instanceId ? ` instance "${instanceId}"` : ''}`);
+        }
+        return binding;
+    }
+    async stopWorkspace(workspaceId, instanceId) {
+        const resolved = this.resolveRuntimeState(workspaceId, instanceId);
+        await this.stopWorkspaceKey(resolveRuntimeKey(workspaceId, resolved.instanceId));
+    }
+    async stopWorkspaceKey(key) {
+        const state = this.runtime.get(key);
+        if (!state)
+            return;
+        try {
+            await this.stopWorkspaceTransport(state);
+        }
+        catch (error) {
+            this.options.log?.(`[${this.platform}] stop transport failed for ${state.workspaceId}/${state.instanceId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        this.resetStateToStopped(state, key);
+        this.notifyRuntimeStateChanged();
+    }
+    // ==================== Error Management ====================
+    notifyRuntimeStateChanged() {
+        this.options.eventBus.emit({
+            type: 'runtime.state.changed',
+            payload: {
+                reason: 'channel-bindings',
+            },
+        });
+    }
+    clearRuntimeError(state) {
+        state.lastError = undefined;
+        state.lastErrorInfo = undefined;
+        state.lastErrorAt = undefined;
+    }
+    setRuntimeError(state, errorInfo) {
+        state.lastError = errorInfo.message;
+        state.lastErrorInfo = errorInfo;
+        state.lastErrorAt = new Date().toISOString();
+        this.options.eventBus.emit({
+            type: 'localcore.error',
+            payload: {
+                scope: `channel.${this.platform}`,
+                errorInfo,
+                context: {
+                    workspaceId: state.workspaceId,
+                    instanceId: state.instanceId,
+                    platform: this.platform,
+                },
+            },
+        });
+    }
+}
+exports.BaseChannelGateway = BaseChannelGateway;

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

@@ -13,6 +13,11 @@ class ChannelSessionCommandRuntime {
             content: input.text,
             defaultTitle: input.defaultTitle,
             defaultAgentType: input.defaultAgentType,
+            channel: {
+                chatId: input.chatId,
+                platformUserId: input.platformUserId,
+                platform: input.platformKey,
+            },
         });
         if (!result.handled) {
             return { handled: false, threadId: input.currentThreadId };
@@ -20,7 +25,7 @@ class ChannelSessionCommandRuntime {
         let activeThreadId = input.currentThreadId;
         for (const effect of result.effects || []) {
             if (effect.type === 'created_thread') {
-                this.inheritAgentMode(input.currentThreadId, effect.threadId);
+                this.inheritAgentState(input, input.currentThreadId, effect.threadId);
             }
             if (effect.type === 'activate_thread') {
                 activeThreadId = effect.threadId;
@@ -30,11 +35,17 @@ class ChannelSessionCommandRuntime {
         await this.options.sendResult(input, result);
         return { handled: true, threadId: activeThreadId, result };
     }
-    inheritAgentMode(sourceThreadId, targetThreadId) {
-        const inheritedMode = this.options.store.getThreadRow?.(sourceThreadId)?.agent_mode || '';
+    inheritAgentState(input, sourceThreadId, targetThreadId) {
+        const sourceRow = this.options.store.getThreadRow?.(sourceThreadId);
+        const inheritedMode = sourceRow?.agent_mode || '';
         if (inheritedMode && inheritedMode !== 'default') {
             this.options.store.updateThreadAgentMode?.(targetThreadId, inheritedMode);
         }
+        const binding = this.options.store.getPlatformThreadBinding?.(input.workspaceId, input.chatId, input.platformUserId, input.platformKey);
+        const preferredAgent = binding?.preferred_agent_type || sourceRow?.agent_type || '';
+        if (preferredAgent) {
+            this.options.store.updateThreadAgentType?.(targetThreadId, preferredAgent);
+        }
     }
     activateThread(input, threadId) {
         const now = new Date().toISOString();