@hybrd/xmtp 1.4.4 → 2.0.0

package/src/localStorage.ts.old

@@ -1,203 +0,0 @@
-import { existsSync, mkdirSync } from "node:fs";
-import * as fs from "node:fs/promises";
-import path from "node:path";
-import { validateEnvironment } from "./client";
-import type { WalletInfo, WalletStorage } from "./walletService";
-
-const { XMTP_NETWORK_ID } = validateEnvironment(["XMTP_NETWORK_ID"]);
-export const STORAGE_DIRS = {
-  WALLET: ".data/wallet_data",
-  XMTP: ".data/xmtp",
-};
-
-/**
- * Generic file-based storage service
- */
-export class FileStorage implements WalletStorage {
-  private initialized = false;
-
-  constructor(private baseDirs = STORAGE_DIRS) {
-    this.initialize();
-  }
-
-  /**
-   * Initialize storage directories
-   */
-  public initialize(): void {
-    if (this.initialized) return;
-
-    Object.values(this.baseDirs).forEach((dir) => {
-      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    });
-
-    this.initialized = true;
-  }
-
-  /**
-   * File operations - save/read/delete
-   */
-  private async saveToFile(
-    directory: string,
-    identifier: string,
-    data: string,
-  ): Promise<boolean> {
-    const key = `${identifier}-${XMTP_NETWORK_ID}`;
-    try {
-      await fs.writeFile(path.join(directory, `${key}.json`), data);
-      return true;
-    } catch (error) {
-      console.error(`Error writing to file ${key}:`, error);
-      return false;
-    }
-  }
-
-  private async readFromFile<T>(
-    directory: string,
-    identifier: string,
-  ): Promise<T | null> {
-    try {
-      const key = `${identifier}-${XMTP_NETWORK_ID}`;
-      const data = await fs.readFile(
-        path.join(directory, `${key}.json`),
-        "utf-8",
-      );
-      return JSON.parse(data) as T;
-    } catch (error) {
-      if (
-        error instanceof Error &&
-        (error.message.includes("ENOENT") ||
-          error.message.includes("no such file or directory"))
-      ) {
-        return null;
-      }
-      throw error;
-    }
-  }
-
-  public async deleteFile(directory: string, key: string): Promise<boolean> {
-    try {
-      await fs.unlink(path.join(directory, `${key}.json`));
-      return true;
-    } catch (error) {
-      console.error(`Error deleting file ${key}:`, error);
-      return false;
-    }
-  }
-
-  /**
-   * Generic data operations
-   */
-  public async saveData(
-    category: string,
-    id: string,
-    data: unknown,
-  ): Promise<boolean> {
-    if (!this.initialized) this.initialize();
-
-    // Make sure the directory exists
-    const directory = path.join(".data", category);
-    if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
-
-    return await this.saveToFile(directory, id, JSON.stringify(data));
-  }
-
-  public async getData<T>(category: string, id: string): Promise<T | null> {
-    if (!this.initialized) this.initialize();
-
-    const directory = path.join(".data", category);
-    return this.readFromFile<T>(directory, id);
-  }
-
-  public async listData<T>(category: string): Promise<T[]> {
-    if (!this.initialized) this.initialize();
-
-    try {
-      const directory = path.join(".data", category);
-      if (!existsSync(directory)) return [];
-
-      const files = await fs.readdir(directory);
-      const items: T[] = [];
-
-      for (const file of files.filter((f) => f.endsWith(".json"))) {
-        const id = file.replace(`-${XMTP_NETWORK_ID}.json`, "");
-        const data = await this.getData<T>(category, id);
-        if (data) items.push(data);
-      }
-
-      return items;
-    } catch (error) {
-      console.error(`Error listing data in ${category}:`, error);
-      return [];
-    }
-  }
-
-  public async deleteData(category: string, id: string): Promise<boolean> {
-    if (!this.initialized) this.initialize();
-
-    try {
-      const directory = path.join(".data", category);
-      const key = `${id}-${XMTP_NETWORK_ID}`;
-      return await this.deleteFile(directory, key);
-    } catch (error) {
-      console.error(`Error deleting data ${id} from ${category}:`, error);
-      return false;
-    }
-  }
-
-  /**
-   * Wallet Storage implementation
-   */
-  public async saveWallet(userId: string, walletData: string): Promise<void> {
-    if (!this.initialized) this.initialize();
-    await this.saveToFile(this.baseDirs.WALLET, userId, walletData);
-  }
-
-  public async getWallet(userId: string): Promise<WalletInfo | null> {
-    if (!this.initialized) this.initialize();
-    return this.readFromFile(this.baseDirs.WALLET, userId);
-  }
-
-  public async getWalletByAddress(address: string): Promise<WalletInfo | null> {
-    if (!this.initialized) this.initialize();
-    try {
-      const directory = this.baseDirs.WALLET;
-      if (!existsSync(directory)) return null;
-
-      const files = await fs.readdir(directory);
-
-      for (const file of files.filter((f) => f.endsWith(".json"))) {
-        try {
-          const data = await fs.readFile(path.join(directory, file), "utf-8");
-          const walletData = JSON.parse(data) as WalletInfo;
-
-          // Check if this wallet has the target address
-          if (walletData.address.toLowerCase() === address.toLowerCase()) {
-            return walletData;
-          }
-        } catch (err) {
-          console.error(`Error parsing wallet data from ${file}:`, err);
-          // Skip files with parsing errors
-          continue;
-        }
-      }
-
-      return null;
-    } catch (error) {
-      console.error(`Error finding wallet by address ${address}:`, error);
-      return null;
-    }
-  }
-
-  public async getWalletCount(): Promise<number> {
-    try {
-      const files = await fs.readdir(this.baseDirs.WALLET);
-      return files.filter((file) => file.endsWith(".json")).length;
-    } catch (error) {
-      console.error("Error getting wallet count:", error);
-      return 0;
-    }
-  }
-}
-
-// Export a single global instance
-export const storage = new FileStorage();

package/src/plugin.filters.test.ts

@@ -1,158 +0,0 @@
-import type { HonoVariables, PluginContext } from "@hybrd/types"
-import { Hono } from "hono"
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
-import { XMTPPlugin } from "./plugin"
-
-// Mock @xmtp/agent-sdk and ./client used by the plugin
-vi.mock("@xmtp/agent-sdk", () => {
-	const handlers: Record<string, Array<(payload: unknown) => unknown>> = {}
-	const fakeXmtp = {
-		on: (event: string, cb: (payload: unknown) => unknown) => {
-			if (!handlers[event]) handlers[event] = []
-			handlers[event].push(cb)
-		},
-		emit: async (event: string, payload: unknown) => {
-			for (const cb of handlers[event] || []) {
-				// eslint-disable-next-line @typescript-eslint/await-thenable
-				await cb(payload)
-			}
-		},
-		start: vi.fn(async () => {})
-	}
-
-	return {
-		Agent: { create: vi.fn(async () => fakeXmtp) },
-		createUser: vi.fn(() => ({ account: { address: "0xabc" } })),
-		createSigner: vi.fn(() => ({})),
-		getTestUrl: vi.fn(() => "http://test"),
-		XmtpEnv: {},
-		__fakeXmtp: fakeXmtp
-	}
-})
-
-vi.mock("./client", () => {
-	const fakeConversation = {
-		id: "conv1",
-		send: vi.fn(async (_text: string) => {})
-	}
-
-	const fakeClient = {
-		inboxId: "inbox-1",
-		accountIdentifier: { identifier: "0xabc" },
-		conversations: {
-			list: vi.fn(async () => [] as unknown[]),
-			getConversationById: vi.fn(async (_id: string) => fakeConversation),
-			streamAllMessages: vi.fn(async function* () {
-				// Yield one message and finish
-				yield {
-					id: "msg1",
-					senderInboxId: "other-inbox",
-					content: "hello",
-					contentType: { sameAs: () => true },
-					conversationId: "conv1"
-				}
-			})
-		}
-	}
-
-	async function getDbPath(_name: string): Promise<string> {
-		return "/tmp/xmtp-test-db"
-	}
-
-	return {
-		createXMTPClient: vi.fn(async () => fakeClient),
-		getDbPath
-	}
-})
-
-type MockAgentSdk = {
-	__fakeXmtp: {
-		emit: (event: string, payload: unknown) => Promise<void>
-	}
-}
-
-function createTestAgent() {
-	return {
-		name: "test-agent",
-		plugins: { applyAll: vi.fn(async () => {}) },
-		createRuntimeContext: vi.fn(
-			async (base: unknown) => base as Record<string, unknown>
-		),
-		generate: vi.fn(async () => ({ text: "ok" }))
-	}
-}
-
-beforeEach(() => {
-	vi.resetModules()
-	vi.clearAllMocks()
-	process.env.XMTP_WALLET_KEY = "0xabc"
-	process.env.XMTP_DB_ENCRYPTION_KEY = "secret"
-	process.env.XMTP_ENV = "dev"
-	process.env.XMTP_ENABLE_NODE_STREAM = undefined
-})
-
-afterEach(() => {
-	process.env.XMTP_WALLET_KEY = undefined
-	process.env.XMTP_DB_ENCRYPTION_KEY = undefined
-	process.env.XMTP_ENV = undefined
-	process.env.XMTP_ENABLE_NODE_STREAM = undefined
-})
-
-describe("XMTPPlugin behaviors", () => {
-	it("blocks node stream messages when behaviors filter out", async () => {
-		const app = new Hono<{ Variables: HonoVariables }>()
-		const agent = createTestAgent()
-
-		// Mock behaviors to filter out messages
-		const mockBehaviors = {
-			executeBefore: vi.fn(async (context: any) => {
-				context.sendOptions = { filtered: true }
-			}),
-			executeAfter: vi.fn(async () => {})
-		}
-
-		const context = {
-			agent,
-			behaviors: mockBehaviors
-		} as unknown as PluginContext
-
-		const plugin = XMTPPlugin()
-		await plugin.apply(app, context)
-
-		// Allow async stream to tick
-		await new Promise((r) => setTimeout(r, 10))
-
-		// No generation or sending should have occurred
-		expect(agent.generate).not.toHaveBeenCalled()
-	})
-
-	it("allows text handler when behaviors don't filter", async () => {
-		const app = new Hono<{ Variables: HonoVariables }>()
-		const agent = createTestAgent()
-
-		// Mock behaviors to not filter messages
-		const mockBehaviors = {
-			executeBefore: vi.fn(async () => {}),
-			executeAfter: vi.fn(async () => {})
-		}
-
-		const context = {
-			agent,
-			behaviors: mockBehaviors
-		} as unknown as PluginContext
-
-		process.env.XMTP_ENABLE_NODE_STREAM = "false"
-		const plugin = XMTPPlugin()
-		await plugin.apply(app, context)
-
-		const mocked = (await import("@xmtp/agent-sdk")) as unknown as MockAgentSdk
-
-		// Emit a text event
-		await mocked.__fakeXmtp.emit("text", {
-			conversation: { id: "conv1", send: vi.fn(async () => {}) },
-			message: { content: "hello" }
-		})
-
-		expect(agent.generate).toHaveBeenCalledTimes(1)
-	})
-})

package/src/service-client.ts.old

@@ -1,309 +0,0 @@
-/**
- * @fileoverview XMTP Service Client Library
- *
- * Clean, reusable client for making HTTP calls to the XMTP listener service.
- * Handles authentication, request formatting, and error handling.
- *
- * This is different from the direct XMTP client - this is for external services
- * talking to our XMTP listener service.
- */
-
-import type {
-	GetMessageParams,
-	SendMessageParams,
-	SendMessageResponse,
-	SendReactionParams,
-	SendReactionResponse,
-	SendReplyParams,
-	SendReplyResponse,
-	SendTransactionParams,
-	SendTransactionResponse,
-	XmtpServiceClientConfig,
-	XmtpServiceMessage,
-	XmtpServiceResponse
-} from "./types"
-import { logger } from "./lib/logger"
-
-export class XmtpServiceClient {
-	private config: XmtpServiceClientConfig
-
-	constructor(config: XmtpServiceClientConfig) {
-		this.config = config
-	}
-
-	private async request<T = unknown>(
-		endpoint: string,
-		body?: Record<string, unknown>,
-		method: "GET" | "POST" = "POST"
-	): Promise<XmtpServiceResponse<T>> {
-		const startTime = performance.now()
-		logger.debug(`🌐 [HTTP] Starting ${method} request to ${endpoint}`)
-		
-		try {
-			const baseUrl = this.config.serviceUrl.replace(/\/+$/, "")
-
-			// Use Authorization header for xmtp-tools endpoints, query parameter for others
-			const isXmtpToolsEndpoint = endpoint.startsWith("/xmtp-tools/")
-			const url = `${baseUrl}${endpoint}?token=${this.config.serviceToken}`
-
-			const headers: Record<string, string> = {
-				"Content-Type": "application/json"
-			}
-
-			// Add Authorization header for xmtp-tools endpoints
-			if (isXmtpToolsEndpoint) {
-				headers.Authorization = `Bearer ${this.config.serviceToken}`
-			}
-
-			const fetchOptions: RequestInit = {
-				method,
-				headers
-			}
-
-			if (method === "POST" && body) {
-				fetchOptions.body = JSON.stringify(body)
-			}
-
-			const sanitizedUrl = `${baseUrl}${endpoint}?token=***`
-			logger.debug(`🌐 [HTTP] Making fetch request to ${sanitizedUrl}`)
-			const fetchStartTime = performance.now()
-			
-			const response = await fetch(url, fetchOptions)
-			
-			const fetchEndTime = performance.now()
-			logger.debug(`🌐 [HTTP] Fetch completed in ${(fetchEndTime - fetchStartTime).toFixed(2)}ms, status: ${response.status}`)
-
-			if (!response.ok) {
-				let errorMessage = `HTTP ${response.status}`
-				try {
-					const responseText = await response.text()
-					try {
-						const errorData = JSON.parse(responseText) as { error?: string }
-						errorMessage = errorData.error || errorMessage
-					} catch {
-						errorMessage = responseText || errorMessage
-					}
-				} catch {
-					// If we can't read the response at all, use the status
-				}
-				
-				const endTime = performance.now()
-				logger.debug(`🌐 [HTTP] Request failed in ${(endTime - startTime).toFixed(2)}ms: ${errorMessage}`)
-				throw new Error(errorMessage)
-			}
-
-			const jsonStartTime = performance.now()
-			const result = {
-				success: true,
-				data: (await response.json()) as T
-			}
-			const jsonEndTime = performance.now()
-			logger.debug(`🌐 [HTTP] JSON parsing completed in ${(jsonEndTime - jsonStartTime).toFixed(2)}ms`)
-			
-			const endTime = performance.now()
-			logger.debug(`🌐 [HTTP] Total request completed in ${(endTime - startTime).toFixed(2)}ms`)
-			
-			return result
-		} catch (error) {
-			const endTime = performance.now()
-			logger.error(
-				`❌ [XmtpServiceClient] Request to ${endpoint} failed in ${(endTime - startTime).toFixed(2)}ms:`,
-				error
-			)
-			return {
-				success: false,
-				error: error instanceof Error ? error.message : "Unknown error"
-			}
-		}
-	}
-
-	async sendMessage(
-		params: SendMessageParams
-	): Promise<XmtpServiceResponse<SendMessageResponse>> {
-		return this.request<SendMessageResponse>("/xmtp-tools/send", {
-			content: params.content
-		})
-	}
-
-	async sendReply(
-		params: SendReplyParams
-	): Promise<XmtpServiceResponse<SendReplyResponse>> {
-		return this.request<SendReplyResponse>("/xmtp-tools/reply", {
-			content: params.content,
-			messageId: params.messageId
-		})
-	}
-
-	async sendReaction(
-		params: SendReactionParams
-	): Promise<XmtpServiceResponse<SendReactionResponse>> {
-		return this.request<SendReactionResponse>("/xmtp-tools/react", {
-			messageId: params.messageId,
-			emoji: params.emoji,
-			action: params.action
-		})
-	}
-
-	async sendTransaction(
-		params: SendTransactionParams
-	): Promise<XmtpServiceResponse<SendTransactionResponse>> {
-		return this.request<SendTransactionResponse>("/xmtp-tools/transaction", {
-			fromAddress: params.fromAddress,
-			chainId: params.chainId,
-			calls: params.calls.map((call) => ({
-				to: call.to,
-				data: call.data,
-				...(call.gas && { gas: call.gas }),
-				value: call.value || "0x0",
-				metadata: {
-					...call.metadata,
-					chainId: params.chainId,
-					from: params.fromAddress,
-					version: "1"
-				}
-			}))
-		})
-	}
-
-	/**
-	 * Get a single message by ID
-	 */
-	async getMessage(
-		params: GetMessageParams
-	): Promise<XmtpServiceResponse<XmtpServiceMessage>> {
-		return this.request<XmtpServiceMessage>(
-			`/xmtp-tools/messages/${params.messageId}`,
-			undefined,
-			"GET"
-		)
-	}
-
-	// getConversationMessages removed - superseded by thread-based approach
-}
-
-/**
- * Create an XMTP service client from runtime context
- * Expects the runtime context to have xmtpServiceUrl and xmtpServiceToken
- */
-export function createXmtpServiceClient(
-	serviceUrl: string,
-	serviceToken: string
-): XmtpServiceClient {
-	if (!serviceUrl || !serviceToken) {
-		throw new Error("Missing XMTP service URL or token from runtime context")
-	}
-
-	return new XmtpServiceClient({
-		serviceUrl,
-		serviceToken
-	})
-}
-
-export interface XmtpAuthConfig {
-	serviceUrl: string
-	serviceToken: string
-	source: "callback" | "environment"
-}
-
-/**
- * Get XMTP authentication configuration from multiple sources
- * Priority: callback credentials > environment credentials
- */
-export function getXmtpAuthConfig(
-	callbackUrl?: string,
-	callbackToken?: string
-): XmtpAuthConfig | null {
-	// Priority 1: Use callback credentials if available
-	if (callbackUrl && callbackToken) {
-		console.log("🔑 [XmtpAuth] Using callback-provided credentials")
-		return {
-			serviceUrl: callbackUrl,
-			serviceToken: callbackToken,
-			source: "callback"
-		}
-	}
-
-	// Priority 2: Use environment credentials
-	const envUrl = process.env.XMTP_HOST
-	const envToken = process.env.XMTP_API_KEY
-
-	if (envUrl && envToken) {
-		console.log("🔑 [XmtpAuth] Using environment credentials")
-		return {
-			serviceUrl: envUrl,
-			serviceToken: envToken,
-			source: "environment"
-		}
-	}
-
-	// No valid credentials found
-	console.error(
-		"❌ [XmtpAuth] No XMTP credentials found in callback or environment"
-	)
-	console.error(
-		"💡 [XmtpAuth] Expected: XMTP_HOST + XMTP_API_KEY or callback credentials"
-	)
-	return null
-}
-
-/**
- * Create an authenticated XMTP service client
- * Handles both callback and environment credential sources
- */
-export function createAuthenticatedXmtpClient(
-	callbackUrl?: string,
-	callbackToken?: string
-): XmtpServiceClient {
-	const authConfig = getXmtpAuthConfig(callbackUrl, callbackToken)
-
-	if (!authConfig) {
-		throw new Error("No XMTP credentials found")
-	}
-
-	console.log(
-		`🔗 [XmtpAuth] Creating XMTP client (${authConfig.source} credentials)`
-	)
-
-	return createXmtpServiceClient(authConfig.serviceUrl, authConfig.serviceToken)
-}
-
-/**
- * Constructs a URL for XMTP tools API endpoints with token authentication
- *
- * @param {string} baseUrl - The base URL of the XMTP service (e.g., "https://api.example.com")
- * @param {string} action - The specific action/endpoint to call (e.g., "send", "receive", "status")
- * @param {string} token - Authentication token (either JWT or API key)
- * @returns {string} Complete URL with token as query parameter
- *
- * @description
- * Builds URLs for XMTP tools endpoints using query parameter authentication.
- * The token is appended as a query parameter for GET request authentication,
- * following the pattern: `/xmtp-tools/{action}?token={token}`
- *
- * @example
- * ```typescript
- * const url = getXMTPToolsUrl(
- *   "https://api.hybrid.dev",
- *   "send",
- *   "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
- * );
- * // Returns: "https://api.hybrid.dev/xmtp-tools/send?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
- * ```
- *
- * @example
- * ```typescript
- * // Using with API key
- * const url = getXMTPToolsUrl(
- *   process.env.XMTP_BASE_URL,
- *   "status",
- *   process.env.XMTP_API_KEY
- * );
- * ```
- */
-export function getXMTPToolsUrl(
-	baseUrl: string,
-	action: string,
-	token: string
-): string {
-	return `${baseUrl}/xmtp-tools/${action}?token=${token}`
-}