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

package/dist/workbuddy/event-handler.js

@@ -0,0 +1,118 @@
+/**
+ * WorkBuddy Event Handler - Handle WeChat KF message events from Centrifuge
+ */
+import { resolvePlatformAiCommand } from '../config.js';
+import { AccessControl } from '../access/access-control.js';
+import { RequestQueue } from '../queue/request-queue.js';
+import { sendTextReply, sendErrorReply } from './message-sender.js';
+import { CommandHandler } from '../commands/handler.js';
+import { getAdapter } from '../adapters/registry.js';
+import { runAITask } from '../shared/ai-task.js';
+import { startTaskCleanup } from '../shared/task-cleanup.js';
+import { WORKBUDDY_THROTTLE_MS } from '../constants.js';
+import { setActiveChatId } from '../shared/active-chats.js';
+import { setChatUser } from '../shared/chat-user-map.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('WorkBuddyHandler');
+export function setupWorkBuddyHandlers(config, sessionManager) {
+    const accessControl = new AccessControl(config.workbuddyAllowedUserIds);
+    const requestQueue = new RequestQueue();
+    const runningTasks = new Map();
+    const taskKeyByChatId = new Map();
+    const stopTaskCleanup = startTaskCleanup(runningTasks);
+    const commandHandler = new CommandHandler({
+        config,
+        sessionManager,
+        requestQueue,
+        sender: {
+            sendTextReply: async (chatId, text) => {
+                // We'll handle this in the AI request
+            },
+        },
+        getRunningTasksSize: () => runningTasks.size,
+    });
+    async function handleAIRequest(userId, chatId, msgId, prompt, workDir, convId) {
+        log.info(`[AI_REQUEST] userId=${userId}, chatId=${chatId}, promptLength=${prompt.length}`);
+        const aiCommand = resolvePlatformAiCommand(config, 'workbuddy');
+        const toolAdapter = getAdapter(aiCommand);
+        if (!toolAdapter) {
+            log.error(`[handleAIRequest] No adapter found for: ${aiCommand}`);
+            await sendErrorReply(null, chatId, `AI tool is not configured: ${aiCommand}`, msgId);
+            return;
+        }
+        const sessionId = convId
+            ? sessionManager.getSessionIdForConv(userId, convId, aiCommand)
+            : undefined;
+        log.info(`[handleAIRequest] Running ${aiCommand} for user ${userId}, sessionId=${sessionId ?? 'new'}`);
+        const toolId = aiCommand;
+        const taskKey = `${userId}:${msgId}`;
+        await runAITask({ config, sessionManager }, { userId, chatId, workDir, sessionId, convId, platform: 'workbuddy', taskKey }, prompt, toolAdapter, {
+            throttleMs: WORKBUDDY_THROTTLE_MS,
+            streamUpdate: async (content) => {
+                // WorkBuddy doesn't support streaming updates via Centrifuge
+                log.debug(`Stream update (not sent): ${content.substring(0, 50)}...`);
+            },
+            sendComplete: async (content) => {
+                await sendTextReply(null, chatId, content, msgId);
+            },
+            sendError: async (error) => {
+                await sendErrorReply(null, chatId, error, msgId);
+            },
+            extraCleanup: () => {
+                runningTasks.delete(taskKey);
+                if (taskKeyByChatId.get(chatId) === taskKey) {
+                    taskKeyByChatId.delete(chatId);
+                }
+            },
+            onTaskReady: (state) => {
+                runningTasks.set(taskKey, state);
+                taskKeyByChatId.set(chatId, taskKey);
+            },
+        });
+    }
+    async function handleEvent(chatId, msgId, content) {
+        log.info(`[handleEvent] chatId=${chatId}, msgId=${msgId}, content="${content.substring(0, 100)}"`);
+        // Use chatId as userId for WorkBuddy (WeChat KF doesn't have separate userId)
+        const userId = chatId;
+        const text = content.trim();
+        if (!accessControl.isAllowed(userId)) {
+            log.warn(`Access denied for sender: ${userId}`);
+            await sendErrorReply(null, chatId, `Access denied. Your chat ID: ${userId}`, msgId);
+            return;
+        }
+        setActiveChatId('workbuddy', chatId);
+        setChatUser(chatId, userId, 'workbuddy');
+        const workDir = sessionManager.getWorkDir(userId);
+        const convId = sessionManager.getConvId(userId);
+        // Try command handler first
+        try {
+            const handled = await commandHandler.dispatch(text, chatId, userId, 'workbuddy', (u, c, p, w, conv, _r, m) => handleAIRequest(u, c, msgId, p, w, conv));
+            if (handled) {
+                log.info(`Command handled for message: ${text}`);
+                return;
+            }
+        }
+        catch (err) {
+            log.error('Error in commandHandler.dispatch:', err);
+        }
+        // No command, proceed with AI request
+        if (!text) {
+            return;
+        }
+        const enqueueResult = requestQueue.enqueue(userId, convId, text, async (nextPrompt) => {
+            log.info(`Executing AI request for: ${text}`);
+            await handleAIRequest(userId, chatId, msgId, nextPrompt, workDir, convId);
+        });
+        if (enqueueResult === 'rejected') {
+            await sendErrorReply(null, chatId, 'Request queue is full. Please try again later.', msgId);
+        }
+        else if (enqueueResult === 'queued') {
+            await sendTextReply(null, chatId, 'Your request is queued.', msgId);
+        }
+    }
+    return {
+        stop: () => stopTaskCleanup(),
+        getRunningTaskCount: () => runningTasks.size,
+        handleEvent,
+    };
+}

package/dist/workbuddy/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WorkBuddy Module - CodeBuddy OAuth + Centrifuge WebSocket for WeChat
+ */
+export * from './types.js';
+export * from './oauth.js';
+export * from './centrifuge-client.js';
+export * from './message-sender.js';
+export * from './client.js';

package/dist/workbuddy/index.js

@@ -0,0 +1,8 @@
+/**
+ * WorkBuddy Module - CodeBuddy OAuth + Centrifuge WebSocket for WeChat
+ */
+export * from './types.js';
+export * from './oauth.js';
+export * from './centrifuge-client.js';
+export * from './message-sender.js';
+export * from './client.js';

package/dist/workbuddy/message-sender.d.ts

@@ -0,0 +1,16 @@
+/**
+ * WorkBuddy Message Sender - Send responses to WeChat KF
+ */
+import type { WorkBuddyCentrifugeClient } from './centrifuge-client.js';
+/**
+ * Send text reply to WeChat KF
+ */
+export declare function sendTextReply(_client: WorkBuddyCentrifugeClient | null, chatId: string, text: string, msgId: string): Promise<void>;
+/**
+ * Send error response to WeChat KF
+ */
+export declare function sendErrorReply(_client: WorkBuddyCentrifugeClient | null, chatId: string, error: string, msgId: string): Promise<void>;
+/**
+ * Send streaming chunk to WeChat KF
+ */
+export declare function sendStreamingChunk(_client: WorkBuddyCentrifugeClient | null, chatId: string, text: string, msgId: string): void;

package/dist/workbuddy/message-sender.js

@@ -0,0 +1,51 @@
+/**
+ * WorkBuddy Message Sender - Send responses to WeChat KF
+ */
+import { createLogger } from '../logger.js';
+import { getCentrifugeClient } from './client.js';
+const log = createLogger('WorkBuddySender');
+/**
+ * Send text reply to WeChat KF
+ */
+export async function sendTextReply(_client, chatId, text, msgId) {
+    const client = _client ?? getCentrifugeClient();
+    if (!client) {
+        log.warn('WorkBuddy client not available, cannot send reply');
+        return;
+    }
+    log.info(`Sending WorkBuddy reply to chatId=${chatId}, msgId=${msgId}`);
+    client.sendPromptResponse({
+        session_id: chatId,
+        prompt_id: msgId,
+        content: [{ type: 'text', text }],
+        stop_reason: 'end_turn',
+    });
+}
+/**
+ * Send error response to WeChat KF
+ */
+export async function sendErrorReply(_client, chatId, error, msgId) {
+    const client = _client ?? getCentrifugeClient();
+    if (!client) {
+        log.warn('WorkBuddy client not available, cannot send error');
+        return;
+    }
+    log.info(`Sending WorkBuddy error to chatId=${chatId}, msgId=${msgId}`);
+    client.sendPromptResponse({
+        session_id: chatId,
+        prompt_id: msgId,
+        error,
+        stop_reason: 'error',
+    });
+}
+/**
+ * Send streaming chunk to WeChat KF
+ */
+export function sendStreamingChunk(_client, chatId, text, msgId) {
+    const client = _client ?? getCentrifugeClient();
+    if (!client) {
+        log.warn('WorkBuddy client not available, cannot send chunk');
+        return;
+    }
+    client.sendMessageChunk(chatId, msgId, { type: 'text', text });
+}

package/dist/workbuddy/oauth.d.ts

@@ -0,0 +1,114 @@
+/**
+ * WorkBuddy OAuth - CodeBuddy authentication for WeChat KF integration
+ */
+import type { WorkBuddyCredentials, CentrifugeTokens } from './types.js';
+export declare class WorkBuddyOAuth {
+    private baseUrl;
+    private hostId;
+    accessToken: string;
+    refreshToken: string;
+    userId: string;
+    constructor(baseUrl?: string);
+    private getHeaders;
+    /**
+     * Get login URL and state for OAuth flow
+     */
+    fetchAuthState(): Promise<{
+        authUrl: string;
+        state: string;
+    }>;
+    /**
+     * Poll for OAuth token after user completes login
+     */
+    pollToken(state: string, signal?: AbortSignal, timeoutMs?: number): Promise<{
+        accessToken: string;
+        refreshToken: string;
+        userId?: string;
+    }>;
+    /**
+     * Get account info
+     */
+    getAccount(state: string, signal?: AbortSignal): Promise<Record<string, unknown>>;
+    /**
+     * Refresh access token
+     */
+    refreshTokenAuth(): Promise<{
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    /**
+     * Build sessionId for WorkBuddy workspace
+     */
+    buildSessionId(workspacePath?: string): string;
+    /**
+     * Get WeChat KF binding link
+     */
+    getWeChatKfLink(sessionId: string, userId?: string): Promise<{
+        success: boolean;
+        url?: string;
+        expiresIn?: number;
+        message?: string;
+    }>;
+    /**
+     * Check WeChat KF binding status
+     */
+    getWeChatKfBindStatus(sessionId: string): Promise<{
+        success: boolean;
+        bound: boolean;
+        externalUserId?: string;
+        boundAt?: string;
+        nickname?: string;
+        avatar?: string;
+        message?: string;
+    }>;
+    /**
+     * Poll binding status until bound
+     */
+    pollBindStatus(sessionId: string, intervalMs?: number, timeoutMs?: number): Promise<{
+        bound: boolean;
+        nickname?: string;
+        avatar?: string;
+        externalUserId?: string;
+    }>;
+    /**
+     * Register workspace to get Centrifuge connection tokens
+     */
+    registerWorkspace(params: {
+        userId: string;
+        hostId: string;
+        workspaceId: string;
+        workspaceName: string;
+    }): Promise<CentrifugeTokens>;
+    /**
+     * Register channel for WeChat KF
+     */
+    registerChannel(params: {
+        type: string;
+        sessionId: string;
+        channelId?: string;
+        [key: string]: unknown;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Send response to WeChat KF
+     */
+    sendResponse(payload: {
+        type: string;
+        msgId: string;
+        chatId: string;
+        success: boolean;
+        message: string;
+        metadata: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Load credentials from object
+     */
+    loadCredentials(creds: Partial<WorkBuddyCredentials>): void;
+    /**
+     * Export credentials
+     */
+    exportCredentials(): WorkBuddyCredentials;
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated(): boolean;
+}

package/dist/workbuddy/oauth.js

@@ -0,0 +1,310 @@
+/**
+ * WorkBuddy OAuth - CodeBuddy authentication for WeChat KF integration
+ */
+import { hostname } from 'node:os';
+import { createLogger } from '../logger.js';
+const log = createLogger('WorkBuddyOAuth');
+const DEFAULT_BASE_URL = 'https://copilot.tencent.com';
+const PLATFORM = 'ide';
+export class WorkBuddyOAuth {
+    baseUrl;
+    hostId;
+    // Credentials
+    accessToken = '';
+    refreshToken = '';
+    userId = '';
+    constructor(baseUrl = DEFAULT_BASE_URL) {
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.hostId = hostname();
+    }
+    getHeaders(auth = true) {
+        const h = {
+            'Content-Type': 'application/json',
+        };
+        if (auth && this.accessToken) {
+            h['Authorization'] = `Bearer ${this.accessToken}`;
+        }
+        return h;
+    }
+    /**
+     * Get login URL and state for OAuth flow
+     */
+    async fetchAuthState() {
+        const url = `${this.baseUrl}/v2/plugin/auth/state?platform=${PLATFORM}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                ...this.getHeaders(false),
+                'X-No-Authorization': 'true',
+                'X-No-User-Id': 'true',
+                'X-No-Enterprise-Id': 'true',
+            },
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok) {
+            throw new Error(`fetchAuthState failed: ${res.status} ${res.statusText}`);
+        }
+        const data = (await res.json());
+        const result = data?.data;
+        if (!result?.authUrl || !result?.state) {
+            throw new Error('fetchAuthState: missing authUrl or state in response');
+        }
+        return { authUrl: result.authUrl, state: result.state };
+    }
+    /**
+     * Poll for OAuth token after user completes login
+     */
+    async pollToken(state, signal, timeoutMs = 5 * 60 * 1000) {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            if (signal?.aborted)
+                throw new Error('登录已取消');
+            await new Promise((r) => setTimeout(r, 1000));
+            try {
+                const url = `${this.baseUrl}/v2/plugin/auth/token?state=${state}`;
+                const res = await fetch(url, {
+                    method: 'GET',
+                    headers: {
+                        ...this.getHeaders(false),
+                        'X-No-Authorization': 'true',
+                    },
+                    signal: AbortSignal.timeout(10_000),
+                });
+                if (!res.ok) {
+                    const body = await res.text().catch(() => '');
+                    // code 11217 = still waiting
+                    if (body.includes('11217'))
+                        continue;
+                    throw new Error(`pollToken: ${res.status} ${body}`);
+                }
+                const data = (await res.json());
+                const token = data?.data;
+                if (token?.accessToken) {
+                    this.accessToken = token.accessToken;
+                    this.refreshToken = token.refreshToken || '';
+                    return {
+                        accessToken: token.accessToken,
+                        refreshToken: token.refreshToken || '',
+                        userId: token.userId,
+                    };
+                }
+            }
+            catch (e) {
+                // code 11217 = still waiting, continue polling
+                if (e?.message?.includes('11217'))
+                    continue;
+                // network errors: retry
+                if (e?.code === 'UND_ERR_CONNECT_TIMEOUT' || e?.code === 'ECONNREFUSED')
+                    continue;
+                throw e;
+            }
+        }
+        throw new Error('登录超时（5 分钟）');
+    }
+    /**
+     * Get account info
+     */
+    async getAccount(state, signal) {
+        const start = Date.now();
+        const timeoutMs = 5 * 60 * 1000;
+        while (Date.now() - start < timeoutMs) {
+            if (signal?.aborted)
+                throw new Error('操作已取消');
+            await new Promise((r) => setTimeout(r, 1000));
+            try {
+                const url = `${this.baseUrl}/v2/plugin/login/account?state=${state}`;
+                const res = await fetch(url, {
+                    method: 'GET',
+                    headers: {
+                        ...this.getHeaders(),
+                        'X-No-User-Id': 'true',
+                        'X-No-Enterprise-Id': 'true',
+                    },
+                    signal: AbortSignal.timeout(10_000),
+                });
+                if (!res.ok) {
+                    const body = await res.text().catch(() => '');
+                    if (body.includes('12151'))
+                        continue;
+                    throw new Error(`getAccount: ${res.status} ${body}`);
+                }
+                const data = (await res.json());
+                if (data?.data)
+                    return data.data;
+            }
+            catch (e) {
+                if (e?.message?.includes('12151'))
+                    continue;
+                throw e;
+            }
+        }
+        throw new Error('获取账号信息超时');
+    }
+    /**
+     * Refresh access token
+     */
+    async refreshTokenAuth() {
+        const url = `${this.baseUrl}/v2/plugin/auth/token/refresh`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                ...this.getHeaders(),
+                'X-Refresh-Token': this.refreshToken,
+                'X-Auth-Refresh-Source': 'ide-main',
+            },
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok) {
+            const status = res.status;
+            if (status === 401 || status === 403) {
+                throw new Error('Token 已过期，请重新登录');
+            }
+            throw new Error(`refreshToken failed: ${status} ${res.statusText}`);
+        }
+        const data = (await res.json());
+        const token = data?.data;
+        if (token?.accessToken) {
+            this.accessToken = token.accessToken;
+            if (token.refreshToken)
+                this.refreshToken = token.refreshToken;
+            return { accessToken: token.accessToken, refreshToken: token.refreshToken || this.refreshToken };
+        }
+        throw new Error('refreshToken: missing accessToken in response');
+    }
+    /**
+     * Build sessionId for WorkBuddy workspace
+     */
+    buildSessionId(workspacePath) {
+        const wp = workspacePath || `${process.env.HOME || process.env.USERPROFILE}/WorkBuddy/Claw`;
+        return `${this.userId}_${this.hostId}_${wp}`;
+    }
+    /**
+     * Get WeChat KF binding link
+     */
+    async getWeChatKfLink(sessionId, userId) {
+        const url = `${this.baseUrl}/v2/backgroundagent/wechatkfProxy/link`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({ sessionId, userId: userId || this.userId }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            return { success: false, message: `获取链接失败: ${res.status} ${body}` };
+        }
+        return (await res.json());
+    }
+    /**
+     * Check WeChat KF binding status
+     */
+    async getWeChatKfBindStatus(sessionId) {
+        const url = `${this.baseUrl}/v2/backgroundagent/wechatkfProxy/bindStatus?sessionId=${encodeURIComponent(sessionId)}`;
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: this.getHeaders(),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok) {
+            return { success: false, bound: false, message: `查询状态失败: ${res.status}` };
+        }
+        return (await res.json());
+    }
+    /**
+     * Poll binding status until bound
+     */
+    async pollBindStatus(sessionId, intervalMs = 10_000, timeoutMs = 5 * 60 * 1000) {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            await new Promise((r) => setTimeout(r, intervalMs));
+            const result = await this.getWeChatKfBindStatus(sessionId);
+            if (result.success && result.bound) {
+                return {
+                    bound: true,
+                    nickname: result.nickname,
+                    avatar: result.avatar,
+                    externalUserId: result.externalUserId,
+                };
+            }
+        }
+        return { bound: false };
+    }
+    /**
+     * Register workspace to get Centrifuge connection tokens
+     */
+    async registerWorkspace(params) {
+        const url = `${this.baseUrl}/v2/agentos/localagent/registerWorkspace`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({
+                ...params,
+                localAgentType: 'ide',
+            }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok)
+            throw new Error(`registerWorkspace failed: ${res.status} ${res.statusText}`);
+        const data = (await res.json());
+        if (!data?.data)
+            throw new Error('registerWorkspace: missing data field');
+        return data.data;
+    }
+    /**
+     * Register channel for WeChat KF
+     */
+    async registerChannel(params) {
+        const url = `${this.baseUrl}/v2/backgroundagent/localProxy/register`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(params),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`registerChannel failed: ${res.status} ${body}`);
+        }
+        return (await res.json());
+    }
+    /**
+     * Send response to WeChat KF
+     */
+    async sendResponse(payload) {
+        const url = `${this.baseUrl}/v2/backgroundagent/wecom/local-proxy/receive`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok)
+            throw new Error(`sendResponse failed: ${res.status} ${res.statusText}`);
+    }
+    /**
+     * Load credentials from object
+     */
+    loadCredentials(creds) {
+        this.accessToken = creds.accessToken || '';
+        this.refreshToken = creds.refreshToken || '';
+        this.userId = creds.userId || '';
+    }
+    /**
+     * Export credentials
+     */
+    exportCredentials() {
+        return {
+            accessToken: this.accessToken,
+            refreshToken: this.refreshToken,
+            userId: this.userId,
+            hostId: this.hostId,
+            baseUrl: this.baseUrl,
+        };
+    }
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated() {
+        return !!this.accessToken && !!this.userId;
+    }
+}