@hybrd/xmtp 1.4.5 → 2.0.0

package/dist/index.js

@@ -17,18 +17,17 @@ var DEFAULT_AMOUNT = "0.1";
 var MAX_USDC_AMOUNT = 10;
 
 // src/client.ts
+import { getRandomValues } from "crypto";
+import fs from "fs";
+import path from "path";
 import { logger } from "@hybrd/utils";
 import { ReactionCodec } from "@xmtp/content-type-reaction";
 import { ReplyCodec } from "@xmtp/content-type-reply";
 import { TransactionReferenceCodec } from "@xmtp/content-type-transaction-reference";
 import { WalletSendCallsCodec } from "@xmtp/content-type-wallet-send-calls";
 import { Client as Client2 } from "@xmtp/node-sdk";
-import { getRandomValues } from "crypto";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
 import { fromString, toString as uint8arraysToString } from "uint8arrays";
-import { createWalletClient, http, toBytes } from "viem";
+import { http, createWalletClient, toBytes as toBytes2 } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 import { sepolia } from "viem/chains";
 
@@ -75,10 +74,10 @@ async function revokeOldInstallations(signer, inboxId) {
   }
 }
 async function main() {
-  const { XMTP_WALLET_KEY } = process.env;
+  const { AGENT_WALLET_KEY } = process.env;
   const inboxId = process.argv[2];
-  if (!XMTP_WALLET_KEY) {
-    console.error("\u274C XMTP_WALLET_KEY is required");
+  if (!AGENT_WALLET_KEY) {
+    console.error("\u274C AGENT_WALLET_KEY is required");
     process.exit(1);
   }
   if (!inboxId) {
@@ -86,7 +85,7 @@ async function main() {
     console.error("Usage: tsx revoke-installations.ts <inboxId>");
     process.exit(1);
   }
-  const signer = createSigner(XMTP_WALLET_KEY);
+  const signer = createSigner(AGENT_WALLET_KEY);
   const identifier = await signer.getIdentifier();
   const address = identifier.identifier;
   console.log(`\u{1F511} Wallet Address: ${address}`);
@@ -99,16 +98,36 @@ async function main() {
     process.exit(1);
   }
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
-  main().catch((error) => {
-    console.error("\u{1F4A5} Fatal error:", error);
-    process.exit(1);
-  });
+try {
+  if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+      console.error("\u{1F4A5} Fatal error:", error);
+      process.exit(1);
+    });
+  }
+} catch {
+}
+
+// src/lib/secret.ts
+import { toBytes } from "viem";
+import { HDKey } from "viem/accounts";
+function deriveAgentSecret(walletKey) {
+  const keyBytes = toBytes(walletKey);
+  const hdKey = HDKey.fromMasterSeed(keyBytes);
+  const child = hdKey.derive("m/44'/60'/0'/0/41");
+  if (!child.privateKey) {
+    throw new Error("Failed to derive child key from wallet key");
+  }
+  return Buffer.from(child.privateKey).toString("hex");
+}
+function resolveAgentSecret(walletKey) {
+  if (!walletKey) {
+    throw new Error("walletKey is required to derive the encryption secret");
+  }
+  return deriveAgentSecret(walletKey);
 }
 
 // src/client.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = path.dirname(__filename);
 var createUser = (key) => {
   const account = privateKeyToAccount(key);
   return {
@@ -139,7 +158,7 @@ var createSigner = (key) => {
         message,
         account: user.account
       });
-      return toBytes(signature);
+      return toBytes2(signature);
     }
   };
 };
@@ -150,8 +169,7 @@ async function clearXMTPDatabase(address, env) {
     if (customStoragePath) {
       return path.isAbsolute(customStoragePath) ? customStoragePath : path.resolve(process.cwd(), customStoragePath);
     }
-    const projectRoot = process.env.PROJECT_ROOT || path.resolve(__dirname, "../../..");
-    return path.join(projectRoot, ".data/xmtp");
+    return path.join(process.cwd(), ".hybrid", ".xmtp");
   };
   const dbPattern = `${env}-${address}.db3`;
   const storageDir = getStorageDirectory();
@@ -160,6 +178,8 @@ async function clearXMTPDatabase(address, env) {
     // Legacy fallback paths for backward compatibility
     path.join(process.cwd(), ".data", "xmtp"),
     path.join(process.cwd(), "..", ".data", "xmtp"),
+    path.join(process.cwd(), "..", "..", ".data", "xmtp"),
+    // Monorepo root fallback
     path.join(process.cwd(), "..", "..", ".data", "xmtp")
   ];
   for (const dir of possiblePaths) {
@@ -189,10 +209,11 @@ async function createXMTPClient(privateKey, opts) {
   const signer = createSigner(privateKey);
   if (!signer) {
     throw new Error(
-      "No signer provided and XMTP_WALLET_KEY environment variable is not set"
+      "No signer provided and AGENT_WALLET_KEY environment variable is not set"
     );
   }
-  const { XMTP_DB_ENCRYPTION_KEY, XMTP_ENV } = process.env;
+  const { XMTP_ENV } = process.env;
+  const agentSecret = resolveAgentSecret(privateKey);
   const identifier = await signer.getIdentifier();
   const address = identifier.identifier;
   while (attempt < maxRetries) {
@@ -205,12 +226,7 @@ async function createXMTPClient(privateKey, opts) {
           "Stateless mode is not supported. XMTP client must run in persistent mode to properly receive and process messages. Set persist: true or remove the persist option to use the default persistent mode."
         );
       }
-      if (!XMTP_DB_ENCRYPTION_KEY) {
-        throw new Error(
-          "XMTP_DB_ENCRYPTION_KEY must be set for persistent mode"
-        );
-      }
-      const dbEncryptionKey = getEncryptionKeyFromHex(XMTP_DB_ENCRYPTION_KEY);
+      const dbEncryptionKey = getEncryptionKeyFromHex(agentSecret);
       const dbPath = await getDbPath(
         `${XMTP_ENV || "dev"}-${address}`,
         storagePath
@@ -239,7 +255,7 @@ async function createXMTPClient(privateKey, opts) {
       return client;
     } catch (error) {
       attempt++;
-      if (error instanceof Error && error.message.includes("5/5 installations")) {
+      if (error instanceof Error && (error.message.includes("installations") || error.message.match(/\d+\/\d+\s+installations/))) {
         console.log(
           `\u{1F4A5} Installation limit reached (attempt ${attempt}/${maxRetries})`
         );
@@ -282,7 +298,7 @@ async function createXMTPClient(privateKey, opts) {
           console.log("\u{1F527} Attempting automatic identity refresh...");
           try {
             console.log("\u{1F4DD} Creating persistent client to refresh identity...");
-            const tempEncryptionKey = XMTP_DB_ENCRYPTION_KEY ? getEncryptionKeyFromHex(XMTP_DB_ENCRYPTION_KEY) : getEncryptionKeyFromHex(generateEncryptionKeyHex());
+            const tempEncryptionKey = getEncryptionKeyFromHex(agentSecret);
             const tempClient = await Client2.create(signer, {
               dbEncryptionKey: tempEncryptionKey,
               env: XMTP_ENV,
@@ -324,10 +340,6 @@ async function createXMTPClient(privateKey, opts) {
   }
   throw new Error("Max retries exceeded");
 }
-var generateEncryptionKeyHex = () => {
-  const uint8Array = getRandomValues(new Uint8Array(32));
-  return uint8arraysToString(uint8Array, "hex");
-};
 var getEncryptionKeyFromHex = (hex) => {
   return fromString(hex, "hex");
 };
@@ -339,8 +351,7 @@ var getDbPath = async (description = "xmtp", storagePath) => {
   } else if (storagePath) {
     volumePath = path.isAbsolute(storagePath) ? storagePath : path.resolve(process.cwd(), storagePath);
   } else {
-    const projectRoot = process.env.PROJECT_ROOT || path.resolve(__dirname, "../../..");
-    volumePath = path.join(projectRoot, ".data/xmtp");
+    volumePath = path.join(process.cwd(), ".hybrid", ".xmtp");
   }
   const dbPath = `${volumePath}/${description}.db3`;
   if (typeof globalThis !== "undefined" && "XMTP_STORAGE" in globalThis) {
@@ -585,8 +596,8 @@ import {
   createSigner as createSigner2,
   createUser as createUser2
 } from "@xmtp/agent-sdk";
-import { logger as logger2 } from "@hybrd/utils";
 import { randomUUID } from "crypto";
+import { logger as logger2 } from "@hybrd/utils";
 async function sendResponse(conversation, text, originalMessageId, behaviorContext) {
   const shouldThread = behaviorContext?.sendOptions?.threaded ?? false;
   if (shouldThread) {
@@ -617,23 +628,16 @@ function XMTPPlugin() {
     name: "xmtp",
     description: "Provides XMTP messaging functionality",
     apply: async (app, context) => {
-      const {
-        XMTP_WALLET_KEY,
-        XMTP_DB_ENCRYPTION_KEY,
-        XMTP_ENV = "production"
-      } = process.env;
+      const { AGENT_WALLET_KEY, XMTP_ENV = "production" } = process.env;
       const { agent } = context;
       const pluginContext = context;
-      if (!XMTP_WALLET_KEY) {
-        throw new Error("XMTP_WALLET_KEY must be set");
+      if (!AGENT_WALLET_KEY) {
+        throw new Error("AGENT_WALLET_KEY must be set");
       }
-      if (!XMTP_DB_ENCRYPTION_KEY) {
-        throw new Error("XMTP_DB_ENCRYPTION_KEY must be set");
-      }
-      const user = createUser2(XMTP_WALLET_KEY);
+      const user = createUser2(AGENT_WALLET_KEY);
       const signer = createSigner2(user);
       const xmtpClient = await createXMTPClient(
-        XMTP_WALLET_KEY
+        AGENT_WALLET_KEY
       );
       const address = user.account.address.toLowerCase();
       const agentDbPath = await getDbPath(
@@ -644,6 +648,8 @@ function XMTPPlugin() {
         env: XMTP_ENV,
         dbPath: agentDbPath
       });
+      const botInboxId = xmtp.client?.inboxId;
+      const MAX_HISTORY = 20;
       xmtp.on("reaction", async ({ conversation, message }) => {
         try {
           const text = message.content.content;
@@ -657,29 +663,52 @@ function XMTPPlugin() {
           const baseRuntime = {
             conversation,
             message,
-            xmtpClient
+            xmtpClient,
+            ...context.scheduler ? { scheduler: context.scheduler } : {}
           };
           const runtime = await agent.createRuntimeContext(baseRuntime);
+          let behaviorContext;
           if (context.behaviors) {
-            const behaviorContext2 = {
+            behaviorContext = {
               runtime,
               client: xmtpClient,
               conversation,
               message
             };
-            await context.behaviors.executeBefore(behaviorContext2);
+            await context.behaviors.executeBefore(behaviorContext);
+            if (behaviorContext.stopped) {
+              logger2.debug(
+                `\u{1F507} [XMTP Plugin] Skipping reaction response due to behavior chain being stopped`
+              );
+              return;
+            }
+            if (behaviorContext.sendOptions?.filtered) {
+              logger2.debug(
+                `\u{1F507} [XMTP Plugin] Skipping reaction response due to message being filtered`
+              );
+              return;
+            }
           }
           const { text: reply } = await agent.generate(messages, { runtime });
-          let behaviorContext;
           if (context.behaviors) {
-            behaviorContext = {
-              runtime,
-              client: xmtpClient,
-              conversation,
-              message,
-              response: reply
-            };
+            if (behaviorContext) {
+              behaviorContext.response = reply;
+            } else {
+              behaviorContext = {
+                runtime,
+                client: xmtpClient,
+                conversation,
+                message,
+                response: reply
+              };
+            }
             await context.behaviors.executeAfter(behaviorContext);
+            if (behaviorContext.stopped) {
+              logger2.debug(
+                `\u{1F507} [XMTP Plugin] Skipping reaction response due to post-behavior chain being stopped`
+              );
+              return;
+            }
           } else {
             behaviorContext = {
               runtime,
@@ -689,12 +718,6 @@ function XMTPPlugin() {
               response: reply
             };
           }
-          if (behaviorContext?.sendOptions?.filtered) {
-            logger2.debug(
-              `\u{1F507} [XMTP Plugin] Skipping reaction response due to message being filtered`
-            );
-            return;
-          }
           await sendResponse(
             conversation,
             reply,
@@ -718,7 +741,8 @@ function XMTPPlugin() {
           const baseRuntime = {
             conversation,
             message,
-            xmtpClient
+            xmtpClient,
+            ...context.scheduler ? { scheduler: context.scheduler } : {}
           };
           const runtime = await agent.createRuntimeContext(baseRuntime);
           let behaviorContext;
@@ -779,13 +803,38 @@ function XMTPPlugin() {
       xmtp.on("text", async ({ conversation, message }) => {
         try {
           const text = message.content;
+          let historyMessages = [];
+          try {
+            console.log("[xmtp] fetching conversation history...");
+            const history = await conversation.messages({
+              limit: MAX_HISTORY + 1,
+              direction: 1
+            });
+            console.log(
+              `[xmtp] got ${history.length} messages from conversation.messages()`
+            );
+            const filtered = history.filter((msg) => msg.id !== message.id).filter(
+              (msg) => msg.content && typeof msg.content === "string"
+            ).slice(0, MAX_HISTORY).reverse();
+            console.log(`[xmtp] after filter: ${filtered.length} messages`);
+            historyMessages = filtered.map((msg) => ({
+              id: msg.id,
+              role: msg.senderInboxId === botInboxId ? "assistant" : "user",
+              parts: [{ type: "text", text: msg.content }]
+            }));
+          } catch (historyErr) {
+            console.error(`[xmtp] history error:`, historyErr);
+          }
           const messages = [
+            ...historyMessages,
             { id: randomUUID(), role: "user", parts: [{ type: "text", text }] }
           ];
+          console.log(`[xmtp] sending ${messages.length} messages to agent`);
           const baseRuntime = {
             conversation,
             message,
-            xmtpClient
+            xmtpClient,
+            ...context.scheduler ? { scheduler: context.scheduler } : {}
           };
           const runtime = await agent.createRuntimeContext(baseRuntime);
           let behaviorContext;
@@ -843,6 +892,7 @@ function XMTPPlugin() {
           logger2.error("\u274C Error handling text:", err);
         }
       });
+      context.xmtpClient = xmtpClient;
       void xmtp.start().then(() => logger2.debug("\u2705 XMTP agent listener started")).catch(
         (err) => console.error("\u274C XMTP agent listener failed to start:", err)
       );
@@ -851,23 +901,23 @@ function XMTPPlugin() {
 }
 
 // src/lib/jwt.ts
-import jwt from "jsonwebtoken";
 import { logger as logger3 } from "@hybrd/utils";
+import jwt from "jsonwebtoken";
 function getJwtSecret() {
-  const secret = process.env.XMTP_DB_ENCRYPTION_KEY;
+  const walletKey = process.env.AGENT_WALLET_KEY;
+  if (walletKey) {
+    return resolveAgentSecret(walletKey);
+  }
   const nodeEnv = process.env.NODE_ENV || "development";
-  if (nodeEnv === "production" && !secret) {
+  if (nodeEnv === "production") {
     throw new Error(
-      "XMTP_DB_ENCRYPTION_KEY environment variable is required in production. Generate a secure random secret for JWT token signing."
-    );
-  }
-  if (!secret) {
-    logger3.warn(
-      "\u26A0\uFE0F  [SECURITY] Using fallback JWT secret for development. Set XMTP_DB_ENCRYPTION_KEY environment variable for production."
+      "AGENT_WALLET_KEY must be set in production for JWT token signing."
     );
-    return "fallback-secret-for-dev-only";
   }
-  return secret;
+  logger3.warn(
+    "\u26A0\uFE0F  [SECURITY] Using fallback JWT secret for development. Set AGENT_WALLET_KEY for production."
+  );
+  return "fallback-secret-for-dev-only";
 }
 var JWT_EXPIRY = 5 * 60;
 function generateXMTPToolsToken(payload) {
@@ -933,10 +983,13 @@ export {
   createUser3 as createUser,
   createXMTPClient,
   createSigner as createXMTPSigner,
+  deriveAgentSecret,
   filter,
   generateXMTPToolsToken,
+  getDbPath,
   getTestUrl,
   logAgentDetails,
+  resolveAgentSecret,
   validateEnvironment
 };
 //# sourceMappingURL=index.js.map