standalone-toolbar-service/dist/toolbar/handlers/rpc-handler.js

独立的Stagewise工具栏服务 - 支持SRPC通信和WebSocket广播，可与MCP反馈收集器集成

export class ToolbarRPCHandler {
    constructor(bridge, broadcastCallback) {
        this.bridge = bridge;
        this.broadcastCallback = broadcastCallback || undefined;
        this.registerMethods();
    }
    registerMethods() {
        this.bridge.register({
            getSessionInfo: this.getSessionInfo.bind(this),
            triggerAgentPrompt: this.triggerAgentPrompt.bind(this),
        });
    }
    async getSessionInfo(request, sendUpdate) {
        console.log('[Toolbar RPC] getSessionInfo called with request:', request);
        sendUpdate({
            status: 'gathering_session_info',
            message: 'Collecting session information...',
        });
        const sessionInfo = {
            sessionId: 'standalone-toolbar-service-session-' + Date.now(),
            appName: 'Standalone Toolbar Service',
            displayName: 'Standalone Toolbar Service - WebSocket Broadcast',
            port: 5748,
            version: '1.0.0',
            features: ['websocket-broadcast', 'toolbar-integration', 'multi-service-support'],
        };
        console.log('[Toolbar RPC] Returning session info:', sessionInfo);
        return sessionInfo;
    }
    async triggerAgentPrompt(request, sendUpdate) {
        console.log('[Toolbar RPC] triggerAgentPrompt called with request:', request);
        const { prompt, model, files, mode, images, sessionId } = request;
        sendUpdate({
            sessionId,
            updateText: 'Processing your prompt...',
            status: 'processing',
        });
        try {
            if (this.broadcastCallback) {
                console.log('[Toolbar RPC] Broadcasting prompt to all WebService clients...');
                sendUpdate({
                    sessionId,
                    updateText: 'Broadcasting prompt to all connected services...',
                    status: 'forwarding',
                });
                const broadcastResult = await this.broadcastCallback({
                    prompt,
                    sessionId: sessionId || `rpc_${Date.now()}`,
                    model,
                    files,
                    images,
                    mode,
                    metadata: {
                        source: 'toolbar_rpc',
                        timestamp: Date.now(),
                        rpcMethod: 'triggerAgentPrompt',
                        service: 'standalone-toolbar-service'
                    },
                    timestamp: Date.now()
                });
                sendUpdate({
                    sessionId,
                    updateText: 'Prompt broadcasted successfully to all services',
                    status: 'forwarded',
                });
                const result = {
                    sessionId,
                    result: {
                        success: true,
                        output: 'Prompt has been broadcasted to all connected WebService instances. All services will receive the prompt simultaneously.',
                        broadcastResult,
                        metadata: {
                            model: model || 'default',
                            mode: mode || 'agent',
                            processedAt: new Date().toISOString(),
                            service: 'standalone-toolbar-service',
                            version: '1.0.0',
                            broadcasted: true,
                            port: 5748
                        }
                    },
                };
                console.log('[Toolbar RPC] Prompt broadcasted successfully:', result);
                return result;
            }
            else {
                console.log('[Toolbar RPC] No broadcast callback available');
                sendUpdate({
                    sessionId,
                    updateText: 'Prompt broadcasting service not available',
                    status: 'error',
                });
                return {
                    sessionId,
                    result: {
                        success: false,
                        error: 'Prompt broadcasting service not available',
                        metadata: {
                            service: 'standalone-toolbar-service',
                            version: '1.0.0',
                            processedAt: new Date().toISOString()
                        }
                    },
                };
            }
        }
        catch (error) {
            console.error('[Toolbar RPC] Error in triggerAgentPrompt:', error);
            sendUpdate({
                sessionId,
                updateText: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
                status: 'error',
            });
            return {
                sessionId,
                result: {
                    success: false,
                    error: error instanceof Error ? error.message : 'Unknown error',
                    metadata: {
                        service: 'standalone-toolbar-service',
                        processedAt: new Date().toISOString()
                    }
                },
            };
        }
    }
}
export const registerRPCMethod = (name, method) => {
    console.log(`[Toolbar RPC] Method registration not implemented: ${name}`);
};
export const callRPCMethod = async (methodName, request, sessionId, sendUpdateCallback) => {
    throw new Error(`RPC method calling not implemented: ${methodName}`);
};
export const getSessionInfo = async (request) => {
    return {
        sessionId: request.sessionId || 'unknown',
        timestamp: new Date().toISOString(),
        status: 'active',
        service: 'standalone-toolbar-service'
    };
};
export const triggerAgentPrompt = async (request) => {
    return {
        sessionId: request.sessionId || 'unknown',
        result: {
            success: false,
            error: 'Direct RPC method calling not supported, use ToolbarRPCHandler instead'
        }
    };
};
export const defaultRPCMethods = {
    getSessionInfo,
    triggerAgentPrompt
};