@hybrd/xmtp 1.0.0 → 1.0.3

package/dist/src/lib/message-listener.test.js

@@ -0,0 +1,303 @@
+import { EventEmitter } from "node:events";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MessageListener } from "./message-listener";
+/**
+ * Check if content contains any of the supported agent mention patterns
+ */
+function hasAgentMention(content) {
+    if (!content)
+        return false;
+    const lowerContent = content.toLowerCase();
+    const mentionPatterns = [
+        "@agent",
+        "@hybrid",
+        "@hybrid.base.eth",
+        "@hybrid.eth",
+        "@agent.eth",
+        "@agent.base.eth"
+    ];
+    return mentionPatterns.some((pattern) => lowerContent.includes(pattern));
+}
+// Mock the XmtpResolver
+vi.mock("./xmtp-resolver", () => ({
+    XmtpResolver: vi.fn().mockImplementation(() => ({
+        resolveAddress: vi.fn().mockResolvedValue("0x456789abcdef"),
+        findRootMessage: vi.fn().mockResolvedValue(null),
+        prePopulateCache: vi.fn().mockResolvedValue(undefined)
+    }))
+}));
+// Mock the BasenameResolver
+vi.mock("./basename-resolver", () => ({
+    BasenameResolver: vi.fn().mockImplementation(() => ({
+        getBasename: vi.fn().mockResolvedValue("testuser.base.eth"),
+        getBasenameAddress: vi.fn().mockResolvedValue("0x456789abcdef"),
+        resolveBasenameProfile: vi.fn().mockResolvedValue({
+            basename: "testuser.base.eth",
+            avatar: "https://example.com/avatar.jpg",
+            description: "Test user profile",
+            twitter: "@testuser",
+            github: "testuser",
+            url: "https://testuser.com"
+        })
+    }))
+}));
+// Mock the ENSResolver
+vi.mock("./ens-resolver", () => ({
+    ENSResolver: vi.fn().mockImplementation(() => ({
+        resolveAddressToENS: vi.fn().mockResolvedValue(null),
+        resolveENSName: vi.fn().mockResolvedValue(null),
+        isENSName: vi.fn().mockReturnValue(false)
+    }))
+}));
+// Mock the subjects
+vi.mock("./subjects", () => ({
+    extractSubjects: vi.fn().mockResolvedValue({})
+}));
+// Mock the XMTP client
+const mockClient = {
+    inboxId: "test-inbox-id",
+    accountIdentifier: { identifier: "0x123" },
+    conversations: {
+        sync: vi.fn(),
+        list: vi.fn().mockResolvedValue([]),
+        streamAllMessages: vi.fn(),
+        getConversationById: vi.fn()
+    },
+    preferences: {
+        inboxStateFromInboxIds: vi.fn()
+    }
+};
+describe("MessageListener", () => {
+    let listener;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        listener = new MessageListener({
+            xmtpClient: mockClient,
+            publicClient: {},
+            filter: ({ message }) => {
+                const content = message.content;
+                return hasAgentMention(content);
+            }
+        });
+    });
+    it("should be an instance of EventEmitter", () => {
+        expect(listener).toBeInstanceOf(EventEmitter);
+    });
+    it("should emit message events with enriched sender information", async () => {
+        const mockMessage = {
+            id: "test-message-id",
+            content: "@agent test message",
+            senderInboxId: "sender-inbox-id",
+            conversationId: "conversation-id",
+            sentAt: new Date(),
+            contentType: { typeId: "text" }
+        };
+        // Mock the stream to emit our test message
+        const mockStream = {
+            async *[Symbol.asyncIterator]() {
+                yield mockMessage;
+            }
+        };
+        mockClient.conversations.streamAllMessages.mockResolvedValue(mockStream);
+        mockClient.conversations.getConversationById.mockResolvedValue({
+            id: "conversation-id"
+        });
+        // Set up message event listener
+        const messageHandler = vi.fn();
+        listener.on("message", messageHandler);
+        // Start the listener (but don't wait for it to complete since it runs indefinitely)
+        const startPromise = listener.start();
+        // Give it a moment to process the message
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        expect(messageHandler).toHaveBeenCalledWith(expect.objectContaining({
+            message: expect.objectContaining({
+                id: "test-message-id",
+                content: "@agent test message",
+                senderInboxId: "sender-inbox-id",
+                conversationId: "conversation-id"
+            }),
+            sender: expect.objectContaining({
+                address: "0x456789abcdef",
+                inboxId: "sender-inbox-id",
+                basename: "testuser.base.eth",
+                name: "testuser.base.eth"
+            }),
+            subjects: expect.any(Object),
+            rootMessage: undefined
+        }));
+        listener.stop();
+    });
+    it("should handle messages without basenames gracefully", async () => {
+        // Mock resolvers to return no basename
+        const listenerWithoutBasename = new MessageListener({
+            xmtpClient: mockClient,
+            publicClient: {},
+            filter: ({ message }) => {
+                const content = message.content;
+                return hasAgentMention(content);
+            }
+        });
+        // Mock basename resolver to return null
+        const mockBasenameResolver = listenerWithoutBasename
+            .basenameResolver;
+        mockBasenameResolver.getBasename = vi.fn().mockResolvedValue(null);
+        const mockMessage = {
+            id: "test-message-id-2",
+            content: "@agent test message 2",
+            senderInboxId: "sender-inbox-id-2",
+            conversationId: "conversation-id-2",
+            sentAt: new Date(),
+            contentType: { typeId: "text" }
+        };
+        const mockStream = {
+            async *[Symbol.asyncIterator]() {
+                yield mockMessage;
+            }
+        };
+        mockClient.conversations.streamAllMessages.mockResolvedValue(mockStream);
+        mockClient.conversations.getConversationById.mockResolvedValue({
+            id: "conversation-id-2"
+        });
+        const messageHandler = vi.fn();
+        listenerWithoutBasename.on("message", messageHandler);
+        const startPromise = listenerWithoutBasename.start();
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        expect(messageHandler).toHaveBeenCalledWith(expect.objectContaining({
+            sender: expect.objectContaining({
+                address: "0x456789abcdef",
+                inboxId: "sender-inbox-id-2",
+                basename: undefined,
+                name: expect.stringContaining("0x4567") // Should use truncated address
+            }),
+            subjects: expect.any(Object),
+            rootMessage: undefined
+        }));
+        listenerWithoutBasename.stop();
+    });
+    it("should handle all supported agent mention patterns", async () => {
+        const mentionPatterns = [
+            "@agent test message",
+            "@hybrid test message",
+            "@hybrid.base.eth test message",
+            "@hybrid.eth test message",
+            "@agent.eth test message",
+            "@agent.base.eth test message"
+        ];
+        for (const content of mentionPatterns) {
+            const testListener = new MessageListener({
+                xmtpClient: mockClient,
+                publicClient: {},
+                filter: ({ message }) => {
+                    const messageContent = message.content;
+                    return hasAgentMention(messageContent);
+                }
+            });
+            const mockMessage = {
+                id: `test-message-${content}`,
+                content: content,
+                senderInboxId: "sender-inbox-id",
+                conversationId: "conversation-id",
+                sentAt: new Date(),
+                contentType: { typeId: "text" }
+            };
+            const mockStream = {
+                async *[Symbol.asyncIterator]() {
+                    yield mockMessage;
+                }
+            };
+            mockClient.conversations.streamAllMessages.mockResolvedValue(mockStream);
+            mockClient.conversations.getConversationById.mockResolvedValue({
+                id: "conversation-id"
+            });
+            const messageHandler = vi.fn();
+            testListener.on("message", messageHandler);
+            const startPromise = testListener.start();
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            expect(messageHandler).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.objectContaining({
+                    content: content
+                })
+            }));
+            testListener.stop();
+        }
+    });
+    it("should allow replies without mention checking", async () => {
+        const testListener = new MessageListener({
+            xmtpClient: mockClient,
+            publicClient: {},
+            filter: ({ message }) => {
+                const contentTypeId = message.contentType?.typeId;
+                if (contentTypeId === "reply") {
+                    return true;
+                }
+                if (contentTypeId === "text") {
+                    const messageContent = message.content;
+                    return hasAgentMention(messageContent);
+                }
+                return false;
+            }
+        });
+        const mockReplyMessage = {
+            id: "test-reply-message",
+            content: { content: "yes I'm in" },
+            senderInboxId: "sender-inbox-id",
+            conversationId: "conversation-id",
+            sentAt: new Date(),
+            contentType: { typeId: "reply" }
+        };
+        const mockStream = {
+            async *[Symbol.asyncIterator]() {
+                yield mockReplyMessage;
+            }
+        };
+        mockClient.conversations.streamAllMessages.mockResolvedValue(mockStream);
+        mockClient.conversations.getConversationById.mockResolvedValue({
+            id: "conversation-id"
+        });
+        const messageHandler = vi.fn();
+        testListener.on("message", messageHandler);
+        const startPromise = testListener.start();
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        expect(messageHandler).toHaveBeenCalledWith(expect.objectContaining({
+            message: expect.objectContaining({
+                content: expect.objectContaining({
+                    content: "yes I'm in"
+                })
+            })
+        }));
+        testListener.stop();
+    });
+    it("should properly clean up when stopped", () => {
+        const removeAllListenersSpy = vi.spyOn(listener, "removeAllListeners");
+        listener.stop();
+        expect(removeAllListenersSpy).toHaveBeenCalled();
+    });
+    it("should get stats", () => {
+        const stats = listener.getStats();
+        expect(stats).toEqual({
+            messageCount: 0,
+            conversationCount: 0,
+            isActive: false
+        });
+    });
+    it("should emit started and stopped events", async () => {
+        const startedHandler = vi.fn();
+        const stoppedHandler = vi.fn();
+        listener.on("started", startedHandler);
+        listener.on("stopped", stoppedHandler);
+        // Mock to prevent infinite stream
+        mockClient.conversations.streamAllMessages.mockResolvedValue({
+            async *[Symbol.asyncIterator]() {
+                // Empty iterator that ends immediately
+            }
+        });
+        await listener.start();
+        // Give a moment for the events to be processed
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(startedHandler).toHaveBeenCalled();
+        listener.stop();
+        // Give a moment for the stop event to be processed
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        expect(stoppedHandler).toHaveBeenCalled();
+    });
+});

package/dist/src/lib/subjects.d.ts

@@ -0,0 +1,24 @@
+import type { BasenameResolver } from "../resolver/basename-resolver";
+import type { ENSResolver } from "../resolver/ens-resolver";
+/**
+ * Extract basenames/ENS names from message content using @mention pattern
+ * @param content The message content to parse
+ * @returns Array of unique names found in the message
+ */
+export declare function extractMentionedNames(content: string): string[];
+/**
+ * Resolve mentioned names to addresses and return as subjects object
+ * @param mentionedNames Array of names to resolve
+ * @param basenameResolver Basename resolver instance
+ * @param ensResolver ENS resolver instance
+ * @returns Promise that resolves to subjects object mapping names to addresses
+ */
+export declare function resolveSubjects(mentionedNames: string[], basenameResolver: BasenameResolver, ensResolver: ENSResolver): Promise<Record<string, `0x${string}`>>;
+/**
+ * Extract subjects from message content (combines extraction and resolution)
+ * @param content The message content to parse
+ * @param basenameResolver Basename resolver instance
+ * @param ensResolver ENS resolver instance
+ * @returns Promise that resolves to subjects object mapping names to addresses
+ */
+export declare function extractSubjects(content: string, basenameResolver: BasenameResolver, ensResolver: ENSResolver): Promise<Record<string, `0x${string}`>>;

package/dist/src/lib/subjects.js

@@ -0,0 +1,68 @@
+/**
+ * Extract basenames/ENS names from message content using @mention pattern
+ * @param content The message content to parse
+ * @returns Array of unique names found in the message
+ */
+export function extractMentionedNames(content) {
+    // Match @basename.eth and @basename.base.eth patterns (case insensitive)
+    const nameRegex = /@([a-zA-Z0-9-_]+\.(?:base\.)?eth)\b/gi;
+    const matches = content.match(nameRegex);
+    if (!matches) {
+        return [];
+    }
+    // Remove @ symbol and deduplicate
+    const names = matches.map((match) => match.slice(1).toLowerCase());
+    return [...new Set(names)];
+}
+/**
+ * Resolve mentioned names to addresses and return as subjects object
+ * @param mentionedNames Array of names to resolve
+ * @param basenameResolver Basename resolver instance
+ * @param ensResolver ENS resolver instance
+ * @returns Promise that resolves to subjects object mapping names to addresses
+ */
+export async function resolveSubjects(mentionedNames, basenameResolver, ensResolver) {
+    const subjects = {};
+    if (mentionedNames.length === 0) {
+        return subjects;
+    }
+    console.log(`🔍 Found ${mentionedNames.length} name mentions:`, mentionedNames);
+    for (const mentionedName of mentionedNames) {
+        try {
+            let resolvedAddress = null;
+            // Check if it's an ENS name (.eth but not .base.eth)
+            if (ensResolver.isENSName(mentionedName)) {
+                console.log(`🔍 Resolving ENS name: ${mentionedName}`);
+                resolvedAddress = await ensResolver.resolveENSName(mentionedName);
+            }
+            else {
+                // It's a basename (.base.eth or other format)
+                console.log(`🔍 Resolving basename: ${mentionedName}`);
+                resolvedAddress =
+                    await basenameResolver.getBasenameAddress(mentionedName);
+            }
+            if (resolvedAddress) {
+                subjects[mentionedName] = resolvedAddress;
+                console.log(`✅ Resolved ${mentionedName} → ${resolvedAddress}`);
+            }
+            else {
+                console.log(`❌ Could not resolve address for: ${mentionedName}`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error resolving ${mentionedName}:`, error);
+        }
+    }
+    return subjects;
+}
+/**
+ * Extract subjects from message content (combines extraction and resolution)
+ * @param content The message content to parse
+ * @param basenameResolver Basename resolver instance
+ * @param ensResolver ENS resolver instance
+ * @returns Promise that resolves to subjects object mapping names to addresses
+ */
+export async function extractSubjects(content, basenameResolver, ensResolver) {
+    const mentionedNames = extractMentionedNames(content);
+    return await resolveSubjects(mentionedNames, basenameResolver, ensResolver);
+}

package/dist/src/resolver/address-resolver.d.ts

@@ -0,0 +1,57 @@
+import type { XmtpClient } from "../types";
+interface AddressResolverOptions {
+    /**
+     * Maximum number of addresses to cache
+     * @default 1000
+     */
+    maxCacheSize?: number;
+    /**
+     * Cache TTL in milliseconds
+     * @default 86400000 (24 hours)
+     */
+    cacheTtl?: number;
+}
+export declare class AddressResolver {
+    private client;
+    private cache;
+    private readonly maxCacheSize;
+    private readonly cacheTtl;
+    constructor(client: XmtpClient, options?: AddressResolverOptions);
+    /**
+     * Resolve user address from inbox ID with caching
+     */
+    resolveAddress(inboxId: string, conversationId?: string): Promise<`0x${string}` | null>;
+    /**
+     * Resolve address from conversation members
+     */
+    private resolveFromConversation;
+    /**
+     * Resolve address from inbox state (network fallback)
+     */
+    private resolveFromInboxState;
+    /**
+     * Get cached address if not expired
+     */
+    private getCachedAddress;
+    /**
+     * Cache address with LRU eviction
+     */
+    private setCachedAddress;
+    /**
+     * Pre-populate cache from existing conversations
+     */
+    prePopulateCache(): Promise<void>;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        hitRate?: number;
+    };
+}
+export {};

package/dist/src/resolver/address-resolver.js

@@ -0,0 +1,168 @@
+export class AddressResolver {
+    constructor(client, options = {}) {
+        this.client = client;
+        this.cache = new Map();
+        this.maxCacheSize = options.maxCacheSize ?? 1000;
+        this.cacheTtl = options.cacheTtl ?? 86400000; // 24 hours
+    }
+    /**
+     * Resolve user address from inbox ID with caching
+     */
+    async resolveAddress(inboxId, conversationId) {
+        // Check cache first (fastest)
+        const cached = this.getCachedAddress(inboxId);
+        if (cached) {
+            console.log(`✅ Resolved user address from cache: ${cached}`);
+            return cached;
+        }
+        let userAddress = undefined;
+        try {
+            // Try conversation members lookup first (faster than network call)
+            if (conversationId) {
+                const conversation = await this.client.conversations.getConversationById(conversationId);
+                if (conversation) {
+                    userAddress = await this.resolveFromConversation(conversation, inboxId);
+                    if (userAddress) {
+                        this.setCachedAddress(inboxId, userAddress);
+                        console.log(`✅ Resolved user address: ${userAddress}`);
+                        return userAddress;
+                    }
+                }
+            }
+            // Fallback to inboxStateFromInboxIds
+            userAddress = await this.resolveFromInboxState(inboxId);
+            if (userAddress) {
+                this.setCachedAddress(inboxId, userAddress);
+                console.log(`✅ Resolved user address via fallback: ${userAddress}`);
+                return userAddress;
+            }
+            console.log(`⚠️ No identifiers found for inbox ${inboxId}`);
+            return null;
+        }
+        catch (error) {
+            console.error(`❌ Error resolving user address for ${inboxId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Resolve address from conversation members
+     */
+    async resolveFromConversation(conversation, inboxId) {
+        try {
+            const members = await conversation.members();
+            const sender = members.find((member) => member.inboxId.toLowerCase() === inboxId.toLowerCase());
+            if (sender) {
+                const ethIdentifier = sender.accountIdentifiers.find((id) => id.identifierKind === 0 // IdentifierKind.Ethereum
+                );
+                if (ethIdentifier) {
+                    return ethIdentifier.identifier;
+                }
+                else {
+                    console.log(`⚠️ No Ethereum identifier found for inbox ${inboxId}`);
+                }
+            }
+            else {
+                console.log(`⚠️ Sender not found in conversation members for inbox ${inboxId}`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error resolving from conversation members:`, error);
+        }
+        return null;
+    }
+    /**
+     * Resolve address from inbox state (network fallback)
+     */
+    async resolveFromInboxState(inboxId) {
+        try {
+            const inboxState = await this.client.preferences.inboxStateFromInboxIds([
+                inboxId
+            ]);
+            const firstState = inboxState?.[0];
+            if (firstState?.identifiers && firstState.identifiers.length > 0) {
+                const firstIdentifier = firstState.identifiers[0];
+                return firstIdentifier?.identifier;
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error resolving from inbox state:`, error);
+        }
+        return null;
+    }
+    /**
+     * Get cached address if not expired
+     */
+    getCachedAddress(inboxId) {
+        const entry = this.cache.get(inboxId);
+        if (!entry)
+            return null;
+        const now = Date.now();
+        if (now - entry.timestamp > this.cacheTtl) {
+            this.cache.delete(inboxId);
+            return null;
+        }
+        return entry.address;
+    }
+    /**
+     * Cache address with LRU eviction
+     */
+    setCachedAddress(inboxId, address) {
+        // Simple LRU: if cache is full, remove oldest entry
+        if (this.cache.size >= this.maxCacheSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(inboxId, {
+            address,
+            timestamp: Date.now()
+        });
+    }
+    /**
+     * Pre-populate cache from existing conversations
+     */
+    async prePopulateCache() {
+        console.log("🔄 Pre-populating address cache...");
+        try {
+            const conversations = await this.client.conversations.list();
+            let cachedCount = 0;
+            for (const conversation of conversations) {
+                try {
+                    const members = await conversation.members();
+                    for (const member of members) {
+                        const ethIdentifier = member.accountIdentifiers.find((id) => id.identifierKind === 0 // IdentifierKind.Ethereum
+                        );
+                        if (ethIdentifier) {
+                            this.setCachedAddress(member.inboxId, ethIdentifier.identifier);
+                            cachedCount++;
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("Error pre-caching conversation members:", error);
+                }
+            }
+            console.log(`✅ Pre-cached ${cachedCount} address mappings`);
+        }
+        catch (error) {
+            console.error("Error pre-populating cache:", error);
+        }
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.cache.clear();
+        console.log("🗑️ Address cache cleared");
+    }
+    /**
+     * Get cache statistics
+     */
+    getCacheStats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.maxCacheSize
+        };
+    }
+}