farcaster.js

import WebSocket from 'ws';
import fetch from 'node-fetch';
import { v4 as uuidv4 } from 'uuid';

const API_BASE_URL = 'https://client.warpcast.com/v2';
const WS_URL = 'wss://ws.warpcast.com/stream';

export const formatMessage = (message) => {
    if (message.serverTimestamp < 1739924345884) {
        return false;
    }
    //console.log(message);
    const name = message.senderContext?.displayName || 
                   message.senderContext?.username || 
                   'Unknown';
    return {
        role: `user`, 
        content: `${name}: ${message.message}`
    };
};

class Farcaster {
    constructor(agentFID, token) {
        this.agentFID = agentFID;
        this.token = token;
    }

    async #makeApiCall(endpoint, method, body) {
        try {
            const response = await fetch(`${API_BASE_URL}${endpoint}`, {
                method,
                headers: {
                    'authorization': `Bearer ${this.token}`,
                    'content-type': 'application/json; charset=utf-8'
                },
                body: JSON.stringify(body)
            });
            return await response.json();
        } catch (error) {
            console.error(`Error making API call to ${endpoint}:`, error);
            throw error;
        }
    }

    async createDirectCastGroup(name, participantFids = []) {
        return this.#makeApiCall('/direct-cast-group', 'PUT', {
            participantFids,
            name
        });
    }

    async addGroupMembers(conversationId, targetFids) {
        return this.#makeApiCall('/direct-cast-group-membership', 'POST', {
            conversationId,
            targetFids,
            action: 'add'
        });
    }

    async promoteGroupMember(conversationId, targetFid) {
        return this.#makeApiCall('/direct-cast-group-membership', 'POST', {
            conversationId,
            targetFid,
            action: 'promote'
        });
    }

    async removeGroupMember(conversationId, targetFid) {
        return this.#makeApiCall('/direct-cast-group-membership', 'POST', {
            conversationId,
            targetFid,
            action: 'remove'
        });
    }

    async sendMessage(conversationId, recipientFids, message ) {
        return this.#makeApiCall('/direct-cast-send', 'PUT', {
            conversationId: conversationId,
            message,
            type: "text",
            recipientFids,
            messageId: uuidv4()
        });
    }

    async sendCast(text, embeds = []) {
        return this.#makeApiCall('/casts', 'POST', {
            text,
            embeds
        });
    }

    connectToWarpcastStream() {
        return new Promise((resolve, reject) => {
            const ws = new WebSocket(WS_URL);

            ws.on('open', () => {
                console.log('Connected to Warpcast WebSocket stream');
                // Send authentication message
                const authMessage = {
                    messageType: "authenticate",
                    data: `Bearer ${this.token}`
                };
                ws.send(JSON.stringify(authMessage));
                resolve(ws);
            });
            ws.on('error', (error) => {
                console.error('WebSocket error:', error);
                reject(error);
            });

            ws.on('close', () => {
                console.log('Disconnected from Warpcast WebSocket stream');
            });
        });
    }

    async getMessages(conversationId, cursor = null, allMessages = []) {
        try {
            let endpoint = `/direct-cast-conversation-messages?conversationId=${conversationId}&limit=50`;
            if (cursor) {
                endpoint += `&cursor=${cursor}`;
            }

            const response = await this.#makeApiCall(endpoint, 'GET');
            const messages = response.result.messages.map(message => formatMessage(message)).filter(Boolean);
            allMessages.push(...messages);

            // If there's a next cursor, recursively fetch more messages
            if (response.next && response.next.cursor) {
                return this.getMessages(conversationId, response.next.cursor, allMessages);
            }

            return allMessages.reverse();
        } catch (error) {
            console.error('Error fetching messages:', error);
            throw error;
        }
    }

    async matchUsers(groupName, userFids, message) {
        try {
            // Create a new direct cast group
            const groupResponse = await this.createDirectCastGroup(groupName, userFids);
            const conversationId = groupResponse.result.conversationId;

            // Promote the first member to admin
            if (userFids.length > 0) {
                await this.promoteGroupMember(conversationId, userFids[0]);
            }

            // Send a message to the group
            await this.sendMessage(conversationId, userFids, message);

            // Leave the group by removing self
            await this.removeGroupMember(conversationId, this.agentFID);

            return {
                success: true,
                conversationId,
                message: 'Successfully created group, promoted member, sent message, and left group'
            };
        } catch (error) {
            console.error('Error in matchUsers:', error);
            return {
                success: false,
                error: error.message
            };
        }
    }
}



export default Farcaster;