@hybrd/xmtp 1.4.4 → 2.0.0

package/dist/index.cjs

@@ -52,10 +52,13 @@ __export(src_exports, {
   createUser: () => import_agent_sdk2.createUser,
   createXMTPClient: () => createXMTPClient,
   createXMTPSigner: () => createSigner,
+  deriveAgentSecret: () => deriveAgentSecret,
   filter: () => import_agent_sdk2.filter,
   generateXMTPToolsToken: () => generateXMTPToolsToken,
+  getDbPath: () => getDbPath,
   getTestUrl: () => import_agent_sdk2.getTestUrl,
   logAgentDetails: () => logAgentDetails,
+  resolveAgentSecret: () => resolveAgentSecret,
   validateEnvironment: () => validateEnvironment
 });
 module.exports = __toCommonJS(src_exports);
@@ -67,19 +70,18 @@ var DEFAULT_AMOUNT = "0.1";
 var MAX_USDC_AMOUNT = 10;
 
 // src/client.ts
+var import_node_crypto = require("crypto");
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
 var import_utils = require("@hybrd/utils");
 var import_content_type_reaction = require("@xmtp/content-type-reaction");
 var import_content_type_reply = require("@xmtp/content-type-reply");
 var import_content_type_transaction_reference = require("@xmtp/content-type-transaction-reference");
 var import_content_type_wallet_send_calls = require("@xmtp/content-type-wallet-send-calls");
 var import_node_sdk2 = require("@xmtp/node-sdk");
-var import_node_crypto = require("crypto");
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
-var import_node_url = require("url");
 var import_uint8arrays = require("uint8arrays");
-var import_viem = require("viem");
-var import_accounts = require("viem/accounts");
+var import_viem2 = require("viem");
+var import_accounts2 = require("viem/accounts");
 var import_chains = require("viem/chains");
 
 // scripts/revoke-installations.ts
@@ -126,10 +128,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) {
@@ -137,7 +139,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}`);
@@ -150,26 +152,45 @@ 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
+var import_viem = require("viem");
+var import_accounts = require("viem/accounts");
+function deriveAgentSecret(walletKey) {
+  const keyBytes = (0, import_viem.toBytes)(walletKey);
+  const hdKey = import_accounts.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 import_meta2 = {};
-var __filename = (0, import_node_url.fileURLToPath)(import_meta2.url);
-var __dirname = import_node_path.default.dirname(__filename);
 var createUser = (key) => {
-  const account = (0, import_accounts.privateKeyToAccount)(key);
+  const account = (0, import_accounts2.privateKeyToAccount)(key);
   return {
     key,
     account,
-    wallet: (0, import_viem.createWalletClient)({
+    wallet: (0, import_viem2.createWalletClient)({
       account,
       chain: import_chains.sepolia,
-      transport: (0, import_viem.http)()
+      transport: (0, import_viem2.http)()
     })
   };
 };
@@ -191,7 +212,7 @@ var createSigner = (key) => {
         message,
         account: user.account
       });
-      return (0, import_viem.toBytes)(signature);
+      return (0, import_viem2.toBytes)(signature);
     }
   };
 };
@@ -202,8 +223,7 @@ async function clearXMTPDatabase(address, env) {
     if (customStoragePath) {
       return import_node_path.default.isAbsolute(customStoragePath) ? customStoragePath : import_node_path.default.resolve(process.cwd(), customStoragePath);
     }
-    const projectRoot = process.env.PROJECT_ROOT || import_node_path.default.resolve(__dirname, "../../..");
-    return import_node_path.default.join(projectRoot, ".data/xmtp");
+    return import_node_path.default.join(process.cwd(), ".hybrid", ".xmtp");
   };
   const dbPattern = `${env}-${address}.db3`;
   const storageDir = getStorageDirectory();
@@ -212,6 +232,8 @@ async function clearXMTPDatabase(address, env) {
     // Legacy fallback paths for backward compatibility
     import_node_path.default.join(process.cwd(), ".data", "xmtp"),
     import_node_path.default.join(process.cwd(), "..", ".data", "xmtp"),
+    import_node_path.default.join(process.cwd(), "..", "..", ".data", "xmtp"),
+    // Monorepo root fallback
     import_node_path.default.join(process.cwd(), "..", "..", ".data", "xmtp")
   ];
   for (const dir of possiblePaths) {
@@ -241,10 +263,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) {
@@ -257,12 +280,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
@@ -291,7 +309,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})`
         );
@@ -334,7 +352,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 import_node_sdk2.Client.create(signer, {
               dbEncryptionKey: tempEncryptionKey,
               env: XMTP_ENV,
@@ -376,10 +394,6 @@ async function createXMTPClient(privateKey, opts) {
   }
   throw new Error("Max retries exceeded");
 }
-var generateEncryptionKeyHex = () => {
-  const uint8Array = (0, import_node_crypto.getRandomValues)(new Uint8Array(32));
-  return (0, import_uint8arrays.toString)(uint8Array, "hex");
-};
 var getEncryptionKeyFromHex = (hex) => {
   return (0, import_uint8arrays.fromString)(hex, "hex");
 };
@@ -391,8 +405,7 @@ var getDbPath = async (description = "xmtp", storagePath) => {
   } else if (storagePath) {
     volumePath = import_node_path.default.isAbsolute(storagePath) ? storagePath : import_node_path.default.resolve(process.cwd(), storagePath);
   } else {
-    const projectRoot = process.env.PROJECT_ROOT || import_node_path.default.resolve(__dirname, "../../..");
-    volumePath = import_node_path.default.join(projectRoot, ".data/xmtp");
+    volumePath = import_node_path.default.join(process.cwd(), ".hybrid", ".xmtp");
   }
   const dbPath = `${volumePath}/${description}.db3`;
   if (typeof globalThis !== "undefined" && "XMTP_STORAGE" in globalThis) {
@@ -633,8 +646,8 @@ var XMTPConnectionManager = class {
 
 // src/plugin.ts
 var import_agent_sdk = require("@xmtp/agent-sdk");
-var import_utils2 = require("@hybrd/utils");
 var import_node_crypto2 = require("crypto");
+var import_utils2 = require("@hybrd/utils");
 async function sendResponse(conversation, text, originalMessageId, behaviorContext) {
   const shouldThread = behaviorContext?.sendOptions?.threaded ?? false;
   if (shouldThread) {
@@ -665,23 +678,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 (!XMTP_DB_ENCRYPTION_KEY) {
-        throw new Error("XMTP_DB_ENCRYPTION_KEY must be set");
+      if (!AGENT_WALLET_KEY) {
+        throw new Error("AGENT_WALLET_KEY must be set");
       }
-      const user = (0, import_agent_sdk.createUser)(XMTP_WALLET_KEY);
+      const user = (0, import_agent_sdk.createUser)(AGENT_WALLET_KEY);
       const signer = (0, import_agent_sdk.createSigner)(user);
       const xmtpClient = await createXMTPClient(
-        XMTP_WALLET_KEY
+        AGENT_WALLET_KEY
       );
       const address = user.account.address.toLowerCase();
       const agentDbPath = await getDbPath(
@@ -692,6 +698,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;
@@ -705,29 +713,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) {
+              import_utils2.logger.debug(
+                `\u{1F507} [XMTP Plugin] Skipping reaction response due to behavior chain being stopped`
+              );
+              return;
+            }
+            if (behaviorContext.sendOptions?.filtered) {
+              import_utils2.logger.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) {
+              import_utils2.logger.debug(
+                `\u{1F507} [XMTP Plugin] Skipping reaction response due to post-behavior chain being stopped`
+              );
+              return;
+            }
           } else {
             behaviorContext = {
               runtime,
@@ -737,12 +768,6 @@ function XMTPPlugin() {
               response: reply
             };
           }
-          if (behaviorContext?.sendOptions?.filtered) {
-            import_utils2.logger.debug(
-              `\u{1F507} [XMTP Plugin] Skipping reaction response due to message being filtered`
-            );
-            return;
-          }
           await sendResponse(
             conversation,
             reply,
@@ -766,7 +791,8 @@ function XMTPPlugin() {
           const baseRuntime = {
             conversation,
             message,
-            xmtpClient
+            xmtpClient,
+            ...context.scheduler ? { scheduler: context.scheduler } : {}
           };
           const runtime = await agent.createRuntimeContext(baseRuntime);
           let behaviorContext;
@@ -827,13 +853,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: (0, import_node_crypto2.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;
@@ -891,6 +942,7 @@ function XMTPPlugin() {
           import_utils2.logger.error("\u274C Error handling text:", err);
         }
       });
+      context.xmtpClient = xmtpClient;
       void xmtp.start().then(() => import_utils2.logger.debug("\u2705 XMTP agent listener started")).catch(
         (err) => console.error("\u274C XMTP agent listener failed to start:", err)
       );
@@ -899,23 +951,23 @@ function XMTPPlugin() {
 }
 
 // src/lib/jwt.ts
-var import_jsonwebtoken = __toESM(require("jsonwebtoken"), 1);
 var import_utils3 = require("@hybrd/utils");
+var import_jsonwebtoken = __toESM(require("jsonwebtoken"), 1);
 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) {
-    import_utils3.logger.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;
+  import_utils3.logger.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) {
@@ -967,10 +1019,13 @@ var import_content_type_wallet_send_calls2 = require("@xmtp/content-type-wallet-
   createUser,
   createXMTPClient,
   createXMTPSigner,
+  deriveAgentSecret,
   filter,
   generateXMTPToolsToken,
+  getDbPath,
   getTestUrl,
   logAgentDetails,
+  resolveAgentSecret,
   validateEnvironment
 });
 //# sourceMappingURL=index.cjs.map