@wu529778790/open-im 1.8.1-beta.2 → 1.8.1-beta.21

package/dist/wework/message-sender.js

@@ -101,6 +101,18 @@ function formatWeWorkMessage(title, content, status, note) {
     return message;
 }
 const streamStates = new Map();
+// Periodic cleanup of expired/orphaned stream states
+const STREAM_CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+setInterval(() => {
+    const now = Date.now();
+    for (const [id, state] of streamStates) {
+        if (now - state.createdAt >= STREAM_SAFE_TTL_MS) {
+            state.closed = true;
+            streamStates.delete(id);
+            log.info(`Cleaned up expired stream state: ${id}`);
+        }
+    }
+}, STREAM_CLEANUP_INTERVAL_MS);
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -187,6 +199,12 @@ export async function updateMessage(chatId, streamId, content, status, note, too
             return;
         if (Date.now() - state.createdAt >= STREAM_SAFE_TTL_MS) {
             markExpired(state, streamId);
+            // Stream expired - fall back to text delivery for errors and final states
+            if (status === 'error' || status === 'done') {
+                const reqIdUsed = getReqId(reqId);
+                sendText(reqIdUsed, message);
+                log.info(`Stream expired, sent ${status} via text fallback: streamId=${streamId}`);
+            }
             return;
         }
         state.pendingUpdate = { message, status, reqId };
@@ -207,17 +225,24 @@ export async function sendFinalMessages(chatId, streamId, fullContent, note, too
     const title = getToolTitle(toolId, 'done');
     const parts = splitLongContent(contentToSend, MAX_WEWORK_MESSAGE_LENGTH);
     const finalMessage = formatWeWorkMessage(title, parts[0], 'done', parts.length > 1 ? `内容较长，已分段发送 (1/${parts.length})` : note);
-    try {
-        const state = streamStates.get(streamId);
-        const shouldFallbackToText = !!state && (state.expired || Date.now() - state.createdAt >= STREAM_SAFE_TTL_MS);
-        if (!shouldFallbackToText && state && contentToSend.length > 0) {
-            // 先发一条「输出中」带正文，再发 finish 的最终条，避免企微端一直停在「思考中」不刷新
+    const state = streamStates.get(streamId);
+    const shouldFallbackToText = !!state && (state.expired || Date.now() - state.createdAt >= STREAM_SAFE_TTL_MS);
+    // 先发一条「输出中」带正文，再发 finish 的最终条，避免企微端一直停在「思考中」不刷新
+    // 独立 try-catch：即使此步失败，仍须发送 finish=true，否则企微永远卡在「正在思考」
+    if (!shouldFallbackToText && state && contentToSend.length > 0) {
+        try {
             await updateMessage(chatId, streamId, contentToSend, 'streaming', note, toolId, reqId);
         }
-        if (state) {
-            state.closed = true;
-            state.pendingUpdate = undefined;
+        catch (err) {
+            log.warn('Pre-finish streaming update failed, will still send finish=true:', err);
         }
+    }
+    if (state) {
+        state.closed = true;
+        state.pendingUpdate = undefined;
+    }
+    // finish=true 是关键：必须保证发出，否则企微 UI 永远停留在「正在思考」
+    try {
         if (!shouldFallbackToText) {
             if (state) {
                 const elapsed = Date.now() - state.lastSentAt;
@@ -232,21 +257,28 @@ export async function sendFinalMessages(chatId, streamId, fullContent, note, too
             sendText(getReqId(reqId), finalMessage);
             log.info(`Final stream expired, sent text fallback instead: streamId=${streamId}`);
         }
-        streamStates.delete(streamId);
-        for (let i = 1; i < parts.length; i++) {
-            try {
-                const partContent = `${parts[i]}\n\n_*(续 ${i + 1}/${parts.length})*_`;
-                const partMessage = formatWeWorkMessage(title, partContent, 'done', i === parts.length - 1 ? note : undefined);
-                sendText(getReqId(reqId), partMessage);
-                log.info(`Final message part ${i + 1}/${parts.length} sent`);
-            }
-            catch (err) {
-                log.error(`Failed to send part ${i + 1}:`, err);
-            }
-        }
     }
     catch (err) {
-        log.error('Failed to send final messages:', err);
+        log.warn('Primary finish send failed, trying text fallback:', err);
+        try {
+            sendText(getReqId(reqId), finalMessage);
+            log.info(`Fallback text sent after primary finish failure, streamId=${streamId}`);
+        }
+        catch (fallbackErr) {
+            log.error('Both primary and fallback finish sends failed:', fallbackErr);
+        }
+    }
+    streamStates.delete(streamId);
+    for (let i = 1; i < parts.length; i++) {
+        try {
+            const partContent = `${parts[i]}\n\n_*(续 ${i + 1}/${parts.length})*_`;
+            const partMessage = formatWeWorkMessage(title, partContent, 'done', i === parts.length - 1 ? note : undefined);
+            sendText(getReqId(reqId), partMessage);
+            log.info(`Final message part ${i + 1}/${parts.length} sent`);
+        }
+        catch (err) {
+            log.error(`Failed to send part ${i + 1}:`, err);
+        }
     }
 }
 /**

package/dist/workbuddy/centrifuge-client.d.ts

@@ -0,0 +1,74 @@
+/**
+ * WorkBuddy Centrifuge Client - WebSocket connection for WeChat KF messages
+ */
+import type { WorkBuddyState, PromptResponsePayload } from './types.js';
+/** Centrifuge client configuration */
+export interface CentrifugeClientConfig {
+    url: string;
+    connectionToken: string;
+    subscriptionToken: string;
+    channel: string;
+    guid: string;
+    userId: string;
+    httpBaseUrl?: string;
+    httpAccessToken?: string;
+    workspaceSessionId?: string;
+}
+/** Client callbacks */
+export interface CentrifugeCallbacks {
+    onConnected?: () => void;
+    onDisconnected?: (reason?: string) => void;
+    onError?: (error: Error) => void;
+    onMessage?: (chatId: string, msgId: string, content: string) => void;
+}
+export declare class WorkBuddyCentrifugeClient {
+    private config;
+    private callbacks;
+    private client;
+    private sub;
+    private extraSubs;
+    private state;
+    private processedMsgIds;
+    private static readonly MAX_MSG_ID_CACHE;
+    constructor(config: CentrifugeClientConfig, callbacks?: CentrifugeCallbacks);
+    get logPrefix(): string;
+    getState(): WorkBuddyState;
+    start(): void;
+    stop(): void;
+    setCallbacks(callbacks: Partial<CentrifugeCallbacks>): void;
+    /**
+     * Subscribe to additional channel
+     */
+    subscribeChannel(channel: string, subscriptionToken: string): void;
+    /**
+     * Send message chunk through Centrifuge
+     */
+    sendMessageChunk(sessionId: string, promptId: string, content: {
+        type: string;
+        text?: string;
+    }, guid?: string, userId?: string): void;
+    /**
+     * Send tool call through Centrifuge
+     */
+    sendToolCall(sessionId: string, promptId: string, toolCall: {
+        id: string;
+        name: string;
+        input?: Record<string, unknown>;
+    }, guid?: string, userId?: string): void;
+    /**
+     * Send prompt response (for WeChat KF, use HTTP instead)
+     */
+    sendPromptResponse(payload: PromptResponsePayload, _guid?: string, _userId?: string): void;
+    /**
+     * Handle incoming publication from Centrifuge
+     */
+    private handlePublication;
+    /**
+     * Send AGP envelope through Centrifuge
+     */
+    private sendEnvelope;
+    /**
+     * Clean up old message IDs from cache
+     */
+    private cleanMsgIdCache;
+}

package/dist/workbuddy/centrifuge-client.js

@@ -0,0 +1,272 @@
+/**
+ * WorkBuddy Centrifuge Client - WebSocket connection for WeChat KF messages
+ */
+import { Centrifuge } from 'centrifuge';
+import { WebSocket } from 'ws';
+import { randomUUID } from 'node:crypto';
+import { createLogger } from '../logger.js';
+const log = createLogger('WorkBuddyCentrifuge');
+export class WorkBuddyCentrifugeClient {
+    config;
+    callbacks;
+    client = null;
+    sub = null;
+    extraSubs = [];
+    state = 'disconnected';
+    processedMsgIds = new Set();
+    static MAX_MSG_ID_CACHE = 1000;
+    constructor(config, callbacks = {}) {
+        this.config = config;
+        this.callbacks = callbacks;
+    }
+    get logPrefix() {
+        return `[workbuddy:${this.config.userId}]`;
+    }
+    getState() {
+        return this.state;
+    }
+    start() {
+        if (this.state === 'connected' || this.state === 'connecting') {
+            log.info(`${this.logPrefix} Already connected or connecting`);
+            return;
+        }
+        this.state = 'connecting';
+        log.info(`${this.logPrefix} Connecting to: ${this.config.url}, channel=${this.config.channel}`);
+        this.client = new Centrifuge(this.config.url, {
+            token: this.config.connectionToken,
+            websocket: WebSocket,
+        });
+        this.client.on('connected', (ctx) => {
+            log.info(`${this.logPrefix} Connected (transport=${ctx.transport})`);
+            this.state = 'connected';
+            this.callbacks.onConnected?.();
+        });
+        this.client.on('disconnected', (ctx) => {
+            log.info(`${this.logPrefix} Disconnected: code=${ctx.code}, reason=${ctx.reason}`);
+            if (this.state !== 'disconnected') {
+                this.state = 'disconnected';
+                this.callbacks.onDisconnected?.(ctx.reason || `code=${ctx.code}`);
+            }
+        });
+        this.client.on('connecting', (ctx) => {
+            log.info(`${this.logPrefix} Reconnecting: code=${ctx.code}, reason=${ctx.reason}`);
+            if (this.state === 'connected') {
+                this.state = 'reconnecting';
+            }
+        });
+        this.client.on('error', (ctx) => {
+            log.error(`${this.logPrefix} Error: ${ctx.error.message}`);
+            this.callbacks.onError?.(new Error(ctx.error.message));
+        });
+        // Create channel subscription
+        this.sub = this.client.newSubscription(this.config.channel, {
+            token: this.config.subscriptionToken,
+        });
+        this.sub.on('publication', (ctx) => {
+            this.handlePublication(ctx.data);
+        });
+        this.sub.on('error', (ctx) => {
+            log.error(`${this.logPrefix} Subscription error: ${ctx.error.message}`);
+        });
+        this.sub.subscribe();
+        this.client.connect();
+    }
+    stop() {
+        log.info(`${this.logPrefix} Stopping...`);
+        this.state = 'disconnected';
+        this.processedMsgIds.clear();
+        for (const sub of this.extraSubs) {
+            sub.unsubscribe();
+        }
+        this.extraSubs = [];
+        if (this.sub) {
+            this.sub.unsubscribe();
+            this.sub = null;
+        }
+        if (this.client) {
+            this.client.disconnect();
+            this.client = null;
+        }
+        log.info(`${this.logPrefix} Stopped`);
+    }
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+    /**
+     * Subscribe to additional channel
+     */
+    subscribeChannel(channel, subscriptionToken) {
+        if (!this.client) {
+            log.warn(`${this.logPrefix} Cannot subscribe: client not initialized`);
+            return;
+        }
+        log.info(`${this.logPrefix} Subscribing to additional channel: ${channel}`);
+        const sub = this.client.newSubscription(channel, { token: subscriptionToken });
+        sub.on('publication', (ctx) => {
+            this.handlePublication(ctx.data);
+        });
+        sub.on('error', (ctx) => {
+            log.error(`${this.logPrefix} Extra subscription error (${channel}): ${ctx.error.message}`);
+        });
+        sub.on('subscribed', () => {
+            log.info(`${this.logPrefix} Extra channel subscribed: ${channel}`);
+        });
+        this.extraSubs.push(sub);
+        sub.subscribe();
+    }
+    /**
+     * Send message chunk through Centrifuge
+     */
+    sendMessageChunk(sessionId, promptId, content, guid, userId) {
+        const payload = {
+            session_id: sessionId,
+            prompt_id: promptId,
+            update_type: 'message_chunk',
+            content: [content],
+        };
+        this.sendEnvelope('session.update', payload, guid, userId);
+    }
+    /**
+     * Send tool call through Centrifuge
+     */
+    sendToolCall(sessionId, promptId, toolCall, guid, userId) {
+        const payload = {
+            session_id: sessionId,
+            prompt_id: promptId,
+            update_type: 'tool_call',
+            tool_call: toolCall,
+        };
+        this.sendEnvelope('session.update', payload, guid, userId);
+    }
+    /**
+     * Send prompt response (for WeChat KF, use HTTP instead)
+     */
+    sendPromptResponse(payload, _guid, _userId) {
+        // WeChat KF messages: send via HTTP COPILOT_RESPONSE
+        if (this.config.httpBaseUrl && this.config.httpAccessToken) {
+            const message = payload.content?.map((c) => c.text).join('') || payload.error || '';
+            const httpPayload = {
+                type: 'COPILOT_RESPONSE',
+                msgId: payload.prompt_id,
+                chatId: payload.session_id,
+                success: payload.stop_reason === 'end_turn',
+                message,
+                metadata: {
+                    sessionId: this.config.workspaceSessionId || payload.session_id,
+                    requestId: payload.prompt_id,
+                    state: payload.stop_reason === 'end_turn' ? 'completed' : payload.stop_reason,
+                },
+            };
+            const url = `${this.config.httpBaseUrl}/v2/backgroundagent/wecom/local-proxy/receive`;
+            fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.config.httpAccessToken}`,
+                },
+                body: JSON.stringify(httpPayload),
+                signal: AbortSignal.timeout(30_000),
+            })
+                .then(async (res) => {
+                if (!res.ok) {
+                    const body = await res.text().catch(() => '');
+                    log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE failed: ${res.status} ${body.substring(0, 200)}`);
+                }
+            })
+                .catch((err) => {
+                log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE error:`, err);
+            });
+            return;
+        }
+        this.sendEnvelope('session.promptResponse', payload, _guid, _userId);
+    }
+    /**
+     * Handle incoming publication from Centrifuge
+     */
+    handlePublication(data) {
+        try {
+            const raw = data;
+            // AGP format message (from QClaw gateway)
+            if (raw?.method && raw?.msg_id) {
+                const envelope = raw;
+                if (this.processedMsgIds.has(envelope.msg_id)) {
+                    log.debug(`${this.logPrefix} Duplicate message, skipping: ${envelope.msg_id}`);
+                    return;
+                }
+                this.processedMsgIds.add(envelope.msg_id);
+                this.cleanMsgIdCache();
+                log.debug(`${this.logPrefix} Received AGP message: method=${envelope.method}, msg_id=${envelope.msg_id}`);
+                if (envelope.method === 'session.prompt') {
+                    const payload = envelope.payload;
+                    const content = payload.content?.find((c) => c.type === 'text')?.text || '';
+                    this.callbacks.onMessage?.(payload.session_id, envelope.msg_id, content);
+                }
+                return;
+            }
+            // WeChat KF format message (from WorkBuddy Centrifuge)
+            if (raw?.chatId && raw?.msgId) {
+                const msgId = String(raw.msgId);
+                if (this.processedMsgIds.has(msgId)) {
+                    log.debug(`${this.logPrefix} Duplicate message, skipping: ${msgId}`);
+                    return;
+                }
+                this.processedMsgIds.add(msgId);
+                this.cleanMsgIdCache();
+                const content = String(raw.content ?? '');
+                const chatId = String(raw.chatId);
+                log.info(`${this.logPrefix} Received WeChat KF message: msgId=${msgId}, chatId=${chatId}, content=${content.substring(0, 50)}`);
+                this.callbacks.onMessage?.(chatId, msgId, content);
+                return;
+            }
+            const preview = JSON.stringify(data).substring(0, 500);
+            log.warn(`${this.logPrefix} Unknown message format: ${preview}`);
+        }
+        catch (error) {
+            log.error(`${this.logPrefix} Message handling failed:`, error);
+            this.callbacks.onError?.(error instanceof Error ? error : new Error(`Message handling failed: ${String(error)}`));
+        }
+    }
+    /**
+     * Send AGP envelope through Centrifuge
+     */
+    sendEnvelope(method, payload, guid, userId) {
+        if (!this.client || this.state !== 'connected') {
+            log.warn(`${this.logPrefix} Cannot send message, state: ${this.state}`);
+            return;
+        }
+        const envelope = {
+            msg_id: randomUUID(),
+            guid: guid ?? this.config.guid,
+            user_id: userId ?? this.config.userId,
+            method: method,
+            payload,
+        };
+        try {
+            this.client.publish(this.config.channel, envelope).catch((err) => {
+                log.error(`${this.logPrefix} Message send failed:`, err);
+                this.callbacks.onError?.(err instanceof Error ? err : new Error(String(err)));
+            });
+            const json = JSON.stringify(envelope);
+            const preview = json.length > 500 ? json.substring(0, 500) + `...(truncated)` : json;
+            log.debug(`${this.logPrefix} Sent message: method=${method}, msg_id=${envelope.msg_id}`);
+        }
+        catch (error) {
+            log.error(`${this.logPrefix} Message send failed:`, error);
+            this.callbacks.onError?.(error instanceof Error ? error : new Error(`Message send failed: ${String(error)}`));
+        }
+    }
+    /**
+     * Clean up old message IDs from cache
+     */
+    cleanMsgIdCache() {
+        if (this.processedMsgIds.size > WorkBuddyCentrifugeClient.MAX_MSG_ID_CACHE) {
+            const entries = [...this.processedMsgIds];
+            this.processedMsgIds.clear();
+            entries
+                .slice(-WorkBuddyCentrifugeClient.MAX_MSG_ID_CACHE / 2)
+                .forEach((id) => {
+                this.processedMsgIds.add(id);
+            });
+        }
+    }
+}

package/dist/workbuddy/client.d.ts

@@ -0,0 +1,27 @@
+/**
+ * WorkBuddy Client - Main client for WorkBuddy WeChat integration
+ */
+import type { Config } from '../config.js';
+import { WorkBuddyOAuth } from './oauth.js';
+import { WorkBuddyCentrifugeClient } from './centrifuge-client.js';
+import type { WorkBuddyState } from './types.js';
+/**
+ * Get current channel state
+ */
+export declare function getChannelState(): WorkBuddyState;
+/**
+ * Initialize WorkBuddy client with CodeBuddy OAuth and Centrifuge WebSocket
+ */
+export declare function initWorkBuddy(config: Config, eventHandler: (chatId: string, msgId: string, content: string) => Promise<void>, onStateChange?: (state: WorkBuddyState) => void): Promise<void>;
+/**
+ * Get Centrifuge client for sending messages
+ */
+export declare function getCentrifugeClient(): WorkBuddyCentrifugeClient | null;
+/**
+ * Get OAuth client
+ */
+export declare function getOAuth(): WorkBuddyOAuth | null;
+/**
+ * Stop WorkBuddy client
+ */
+export declare function stopWorkBuddy(): void;

package/dist/workbuddy/client.js

@@ -0,0 +1,162 @@
+/**
+ * WorkBuddy Client - Main client for WorkBuddy WeChat integration
+ */
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { createLogger } from '../logger.js';
+import { WorkBuddyOAuth } from './oauth.js';
+import { WorkBuddyCentrifugeClient } from './centrifuge-client.js';
+const log = createLogger('WorkBuddy');
+const CREDENTIALS_FILE = 'workbuddy-credentials.json';
+const DEFAULT_BASE_URL = 'https://copilot.tencent.com';
+const DEFAULT_WORKSPACE_ID = 'open-im-workspace';
+const DEFAULT_WORKSPACE_NAME = 'OpenIM Workspace';
+// Global state
+let oauth = null;
+let centrifugeClient = null;
+let channelState = 'disconnected';
+let credentialsPath = null;
+let currentSessionId = null;
+// Event handlers
+let messageHandler = null;
+let stateChangeHandler = null;
+/**
+ * Get current channel state
+ */
+export function getChannelState() {
+    return channelState;
+}
+/**
+ * Initialize WorkBuddy client with CodeBuddy OAuth and Centrifuge WebSocket
+ */
+export async function initWorkBuddy(config, eventHandler, onStateChange) {
+    const platformConfig = config.platforms?.workbuddy;
+    if (!platformConfig?.enabled) {
+        throw new Error('WorkBuddy platform not enabled');
+    }
+    // Check credentials
+    const hasCredentials = platformConfig.accessToken && platformConfig.refreshToken && platformConfig.userId;
+    if (!hasCredentials) {
+        throw new Error('WorkBuddy credentials required: accessToken, refreshToken, userId');
+    }
+    log.info('Initializing WorkBuddy client...');
+    messageHandler = eventHandler;
+    stateChangeHandler = onStateChange ?? null;
+    // Set up credentials storage path
+    const baseDir = config.logDir ?? join(process.env.HOME ?? '', '.open-im');
+    credentialsPath = join(baseDir, 'data');
+    if (!existsSync(credentialsPath)) {
+        mkdirSync(credentialsPath, { recursive: true });
+    }
+    // Initialize OAuth client
+    const baseUrl = platformConfig.baseUrl || DEFAULT_BASE_URL;
+    oauth = new WorkBuddyOAuth(baseUrl);
+    oauth.loadCredentials({
+        accessToken: platformConfig.accessToken,
+        refreshToken: platformConfig.refreshToken,
+        userId: platformConfig.userId,
+    });
+    // Build session ID
+    currentSessionId = oauth.buildSessionId(platformConfig.workspacePath);
+    log.info(`WorkBuddy sessionId: ${currentSessionId ?? ''}`);
+    // Register workspace to get Centrifuge tokens
+    let centrifugeTokens;
+    try {
+        centrifugeTokens = await oauth.registerWorkspace({
+            userId: platformConfig.userId || '',
+            hostId: hostname(),
+            workspaceId: DEFAULT_WORKSPACE_ID,
+            workspaceName: DEFAULT_WORKSPACE_NAME,
+        });
+        log.info(`Registered workspace: channel=${centrifugeTokens.channel}`);
+    }
+    catch (err) {
+        log.error('Failed to register workspace:', err);
+        throw new Error(`WorkBuddy workspace registration failed: ${err}`);
+    }
+    // Generate GUID for this instance
+    const guid = platformConfig.guid || randomUUID();
+    const workspaceSessionId = currentSessionId || '';
+    // Create Centrifuge client
+    const callbacks = {
+        onConnected: () => {
+            log.info('WorkBuddy Centrifuge connected');
+            updateState('connected');
+        },
+        onDisconnected: (reason) => {
+            log.info(`WorkBuddy Centrifuge disconnected: ${reason}`);
+            updateState('disconnected');
+        },
+        onError: (error) => {
+            log.error('WorkBuddy Centrifuge error:', error);
+            updateState('error');
+        },
+        onMessage: async (chatId, msgId, content) => {
+            if (messageHandler) {
+                try {
+                    await messageHandler(chatId, msgId, content);
+                }
+                catch (err) {
+                    log.error('Error in message handler:', err);
+                }
+            }
+        },
+    };
+    centrifugeClient = new WorkBuddyCentrifugeClient({
+        url: centrifugeTokens.url,
+        connectionToken: centrifugeTokens.connectionToken,
+        subscriptionToken: centrifugeTokens.subscriptionToken,
+        channel: centrifugeTokens.channel,
+        guid,
+        userId: platformConfig.userId || '',
+        httpBaseUrl: baseUrl,
+        httpAccessToken: platformConfig.accessToken || '',
+        workspaceSessionId,
+    }, callbacks);
+    // Start Centrifuge client
+    centrifugeClient.start();
+    log.info('WorkBuddy client initialized');
+}
+/**
+ * Get Centrifuge client for sending messages
+ */
+export function getCentrifugeClient() {
+    return centrifugeClient;
+}
+/**
+ * Get OAuth client
+ */
+export function getOAuth() {
+    return oauth;
+}
+/**
+ * Update channel state and notify listeners
+ */
+function updateState(state) {
+    channelState = state;
+    if (stateChangeHandler) {
+        stateChangeHandler(state);
+    }
+    log.debug(`Channel state: ${state}`);
+}
+/**
+ * Stop WorkBuddy client
+ */
+export function stopWorkBuddy() {
+    log.info('Stopping WorkBuddy client...');
+    if (centrifugeClient) {
+        centrifugeClient.stop();
+        centrifugeClient = null;
+    }
+    oauth = null;
+    currentSessionId = null;
+    updateState('disconnected');
+    log.info('WorkBuddy client stopped');
+}
+/**
+ * Helper to get hostname
+ */
+function hostname() {
+    return process.env.HOSTNAME || process.env.COMPUTERNAME || 'unknown';
+}

package/dist/workbuddy/event-handler.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WorkBuddy Event Handler - Handle WeChat KF message events from Centrifuge
+ */
+import { type Config } from '../config.js';
+import type { SessionManager } from '../session/session-manager.js';
+export interface WorkBuddyEventHandlerHandle {
+    stop: () => void;
+    getRunningTaskCount: () => number;
+    handleEvent: (chatId: string, msgId: string, content: string) => Promise<void>;
+}
+export declare function setupWorkBuddyHandlers(config: Config, sessionManager: SessionManager): WorkBuddyEventHandlerHandle;