create-message-kit 1.0.15 → 1.0.17

package/index.js

@@ -19,7 +19,16 @@ program
   .name("byob")
   .description("CLI to initialize projects")
   .action(async () => {
-    intro(pc.red(`Welcome to MessageKit CLI v${version}!`));
+    log.message(`\x1b[38;2;250;105;119m\
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+███╗   ███╗███████╗███████╗███████╗ █████╗  ██████╗ ███████╗██╗  ██╗██╗████████╗
+████╗ ████║██╔════╝██╔════╝██╔════╝██╔══██╗██╔════╝ ██╔════╝██║ ██╔╝██║╚══██╔══╝
+██╔████╔██║█████╗  ███████╗███████╗███████║██║  ███╗█████╗  █████╔╝ ██║   ██║   
+██║╚██╔╝██║██╔══╝  ╚════██║╚════██║██╔══██║██║   ██║██╔══╝  ██╔═██╗ ██║   ██║   
+██║ ╚═╝ ██║███████╗███████║███████║██║  ██║╚██████╔╝███████╗██║  ██╗██║   ██║   
+╚═╝     ╚═╝╚══════╝╚══════╝╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝╚═╝   ╚═╝   
+Powered by XMTP \x1b[0m`);
 
     const { templateType, displayName, destDir } = await gatherProjectInfo();
 
@@ -57,7 +66,7 @@ program.parse(process.argv);
 async function gatherProjectInfo() {
   const templateOptions = [
     { value: "gm", label: "GM" },
-    { value: "one-to-one", label: "One-to-One" },
+    { value: "agent", label: "Agent" },
     { value: "group", label: "Group" },
   ];
 
@@ -70,7 +79,7 @@ async function gatherProjectInfo() {
     process.exit(0);
   }
 
-  const templateDir = resolve(__dirname, `./examples/${templateType}`);
+  const templateDir = resolve(__dirname, `./templates/${templateType}`);
 
   // Ensure the template directory exists
   if (!fs.existsSync(templateDir)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-message-kit",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "license": "MIT",
   "type": "module",
   "main": "index.js",
@@ -8,7 +8,7 @@
   "bin": "index.js",
   "files": [
     "index.js",
-    "examples/**/*"
+    "templates/**/*"
   ],
   "scripts": {
     "clean": "rm -rf .turbo && rm -rf node_modules",

package/templates/agent/.env.example

@@ -0,0 +1,2 @@
+KEY= # the private key of the wallet
+OPEN_AI_API_KEY= # sk-proj-...

package/{examples/one-to-one → templates/agent}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "one-to-one",
+  "name": "agent",
   "private": true,
   "type": "module",
   "scripts": {
@@ -8,13 +8,11 @@
     "start": "node dist/index.js"
   },
   "dependencies": {
-    "@redis/client": "^1.5.16",
     "@xmtp/message-kit": "workspace:*",
-    "node-cron": "^3.0.3"
+    "openai": "^4.65.0"
   },
   "devDependencies": {
     "@types/node": "^20.14.2",
-    "@types/node-cron": "^3.0.11",
     "nodemon": "^3.1.3",
     "typescript": "^5.4.5"
   },

package/templates/agent/src/handler/ens.ts

@@ -0,0 +1,211 @@
+import { HandlerContext } from "@xmtp/message-kit";
+import { getUserInfo, clearInfoCache, isOnXMTP } from "../lib/resolver.js";
+import { textGeneration } from "../lib/openai.js";
+import { processResponseWithSkill } from "../lib/openai.js";
+import { isAddress } from "viem";
+import { ens_agent_prompt } from "../prompt.js";
+import { frameUrl, ensUrl, baseTxUrl } from "../index.js";
+import { clearChatHistories } from "../lib/openai.js";
+
+export async function handleEns(context: HandlerContext) {
+  const {
+    message: {
+      content: { command, params, sender },
+    },
+  } = context;
+  if (command == "reset") {
+    clear();
+    return { code: 200, message: "Conversation reset." };
+  } else if (command == "renew") {
+    // Destructure and validate parameters for the ens command
+    const { domain } = params;
+    // Check if the user holds the domain
+    if (!domain) {
+      return {
+        code: 400,
+        message: "Missing required parameters. Please provide domain.",
+      };
+    }
+
+    const data = await getUserInfo(domain);
+
+    if (!data || data?.address !== sender?.address) {
+      return {
+        code: 403,
+        message:
+          "Looks like this domain is not registered to you. Only the owner can renew it.",
+      };
+    }
+
+    // Generate URL for the ens
+    let url_ens = frameUrl + "frames/manage?name=" + domain;
+    return { code: 200, message: `${url_ens}` };
+  } else if (command == "register") {
+    // Destructure and validate parameters for the ens command
+    const { domain } = params;
+
+    if (!domain) {
+      return {
+        code: 400,
+        message: "Missing required parameters. Please provide domain.",
+      };
+    }
+    // Generate URL for the ens
+    let url_ens = ensUrl + domain;
+    return { code: 200, message: `${url_ens}` };
+  } else if (command == "info") {
+    const { domain } = params;
+
+    const data = await getUserInfo(domain);
+    if (!data) {
+      return {
+        code: 404,
+        message: "Domain not found.",
+      };
+    }
+
+    const formattedData = {
+      Address: data?.address,
+      "Avatar URL": data?.ensInfo?.avatar,
+      Description: data?.ensInfo?.description,
+      ENS: data?.ensDomain,
+      "Primary ENS": data?.ensInfo?.ens_primary,
+      GitHub: data?.ensInfo?.github,
+      Resolver: data?.ensInfo?.resolverAddress,
+      Twitter: data?.ensInfo?.twitter,
+      URL: `${ensUrl}${domain}`,
+    };
+
+    let message = "Domain information:\n\n";
+    for (const [key, value] of Object.entries(formattedData)) {
+      if (value) {
+        message += `${key}: ${value}\n`;
+      }
+    }
+    message += `\n\nWould you like to tip the domain owner for getting there first 🤣?`;
+    message = message.trim();
+    if (
+      await isOnXMTP(
+        context.v2client,
+        data?.ensInfo?.ens,
+        data?.ensInfo?.address,
+      )
+    ) {
+      await context.send(
+        `Ah, this domains is in XMTP, you can message it directly: https://converse.xyz/dm/${domain}`,
+      );
+    }
+    return { code: 200, message };
+  } else if (command == "check") {
+    const { domain } = params;
+
+    if (!domain) {
+      return {
+        code: 400,
+        message: "Please provide a domain name to check.",
+      };
+    }
+
+    const data = await getUserInfo(domain);
+    if (!data?.address) {
+      let message = `Looks like ${domain} is available! Do you want to register it? ${ensUrl}${domain} or would you like to see some cool alternatives?`;
+      return {
+        code: 200,
+        message,
+      };
+    } else {
+      let message = `Looks like ${domain} is already registered!`;
+      await context.skill("/cool " + domain);
+      return {
+        code: 404,
+        message,
+      };
+    }
+  } else if (command == "tip") {
+    const { address } = params;
+    if (!address) {
+      return {
+        code: 400,
+        message: "Please provide an address to tip.",
+      };
+    }
+    const data = await getUserInfo(address);
+    let txUrl = `${baseTxUrl}/transaction/?transaction_type=send&buttonName=Tip%20${data?.ensDomain ?? ""}&amount=1&token=USDC&receiver=${
+      isAddress(address) ? address : data?.address
+    }`;
+    console.log(txUrl);
+    return {
+      code: 200,
+      message: txUrl,
+    };
+  } else if (command == "cool") {
+    const { domain } = params;
+    //What about these cool alternatives?\
+    return {
+      code: 200,
+      message: `${generateCoolAlternatives(domain)}`,
+    };
+  }
+}
+
+export async function ensAgent(context: HandlerContext) {
+  if (!process?.env?.OPEN_AI_API_KEY) {
+    console.warn("No OPEN_AI_API_KEY found in .env");
+    return;
+  }
+
+  const {
+    message: {
+      content: { content, params },
+      sender,
+    },
+    group,
+  } = context;
+
+  try {
+    let userPrompt = params?.prompt ?? content;
+    const userInfo = await getUserInfo(sender.address);
+    if (!userInfo) {
+      console.log("User info not found");
+      return;
+    }
+    const { ensDomain, converseUsername } = userInfo;
+
+    const { reply } = await textGeneration(
+      sender.address,
+      userPrompt,
+      await ens_agent_prompt(sender.address, ensDomain, converseUsername),
+      group !== undefined,
+    );
+    await processResponseWithSkill(sender.address, reply, context);
+  } catch (error) {
+    console.error("Error during OpenAI call:", error);
+    await context.send("An error occurred while processing your request.");
+  }
+}
+
+export const generateCoolAlternatives = (domain: string) => {
+  const suffixes = ["lfg", "cool", "degen", "moon", "base", "gm"];
+  const alternatives = [];
+  for (let i = 0; i < 5; i++) {
+    const randomPosition = Math.random() < 0.5;
+    const baseDomain = domain.replace(/\.eth$/, ""); // Remove any existing .eth suffix
+    alternatives.push(
+      randomPosition
+        ? `${suffixes[i]}${baseDomain}.eth`
+        : `${baseDomain}${suffixes[i]}.eth`,
+    );
+  }
+
+  const cool_alternativesFormat = alternatives
+    .map(
+      (alternative: string, index: number) => `${index + 1}. ${alternative} ✨`,
+    )
+    .join("\n");
+  return cool_alternativesFormat;
+};
+
+export async function clear() {
+  clearChatHistories();
+  clearInfoCache();
+}

package/templates/agent/src/index.ts

@@ -0,0 +1,14 @@
+import { run, HandlerContext } from "@xmtp/message-kit";
+import { ensAgent } from "./handler/ens.js";
+
+export const frameUrl = "https://ens.steer.fun/";
+export const ensUrl = "https://app.ens.domains/";
+export const baseTxUrl = "https://base-tx-frame.vercel.app";
+
+run(async (context: HandlerContext) => {
+  const { group, message } = context;
+  /*All the commands are handled through the commands file*/
+  /* If its just text, it will be handled by the ensAgent*/
+  /* If its a group message, it will be handled by the groupAgent*/
+  await ensAgent(context);
+});

package/{examples/group → templates/agent}/src/lib/openai.ts

@@ -1,5 +1,4 @@
 import dotenv from "dotenv";
-import { response } from "express";
 dotenv.config();
 
 import OpenAI from "openai";
@@ -7,12 +6,17 @@ const openai = new OpenAI({
   apiKey: process.env.OPEN_AI_API_KEY,
 });
 
+export type ChatHistoryEntry = { role: string; content: string };
+export type ChatHistories = Record<string, ChatHistoryEntry[]>;
+
+let chatHistories: ChatHistories = {};
 export async function textGeneration(
+  address: string,
   userPrompt: string,
   systemPrompt: string,
-  chatHistory?: any[],
+  isGroup: boolean = false,
 ) {
-  let messages = chatHistory ? [...chatHistory] : []; // Start with existing chat history
+  let messages = chatHistories[address] || [];
   if (messages.length === 0) {
     messages.push({
       role: "system",
@@ -34,7 +38,7 @@ export async function textGeneration(
       content: reply || "No response from OpenAI.",
     });
     const cleanedReply = responseParser(reply as string);
-
+    if (!isGroup) chatHistories[address] = messages;
     return { reply: cleanedReply, history: messages };
   } catch (error) {
     console.error("Failed to fetch from OpenAI:", error);
@@ -79,6 +83,35 @@ export async function vision(imageData: Uint8Array, systemPrompt: string) {
   }
 }
 
+export async function processResponseWithSkill(
+  address: string,
+  reply: string,
+  context: any,
+) {
+  let messages = reply
+    .split("\n")
+    .map((message: string) => responseParser(message))
+    .filter((message): message is string => message.length > 0);
+
+  console.log(messages);
+  for (const message of messages) {
+    if (message.startsWith("/")) {
+      const response = await context.skill(message);
+      if (response && response.message) {
+        let msg = responseParser(response.message);
+
+        chatHistories[address].push({
+          role: "system",
+          content: msg,
+        });
+
+        await context.send(response.message);
+      }
+    } else {
+      await context.send(message);
+    }
+  }
+}
 export function responseParser(message: string) {
   let trimmedMessage = message;
   // Remove bold and underline markdown
@@ -95,5 +128,10 @@ export function responseParser(message: string) {
   trimmedMessage = trimmedMessage?.replace(/^\s+|\s+$/g, "");
   // Remove any remaining leading or trailing whitespace
   trimmedMessage = trimmedMessage.trim();
+
   return trimmedMessage;
 }
+
+export const clearChatHistories = () => {
+  chatHistories = {};
+};

package/templates/agent/src/lib/resolver.ts

@@ -0,0 +1,126 @@
+import { Client } from "@xmtp/xmtp-js";
+import { isAddress } from "viem";
+
+export const converseEndpointURL =
+  "https://converse-website-git-endpoit-ephemerahq.vercel.app";
+//export const converseEndpointURL = "http://localhost:3000";
+
+export type InfoCache = Map<string, UserInfo>;
+export type ConverseProfile = {
+  address: string | null;
+  onXmtp: boolean;
+  avatar: string | null;
+  formattedName: string | null;
+  name: string | null;
+};
+export type UserInfo = {
+  ensDomain?: string | undefined;
+  address?: string | undefined;
+  converseUsername?: string | undefined;
+  ensInfo?: EnsData | undefined;
+  avatar?: string | undefined;
+};
+export interface EnsData {
+  address?: string;
+  avatar?: string;
+  avatar_small?: string;
+  converse?: string;
+  avatar_url?: string;
+  contentHash?: string;
+  description?: string;
+  ens?: string;
+  ens_primary?: string;
+  github?: string;
+  resolverAddress?: string;
+  twitter?: string;
+  url?: string;
+  wallets?: {
+    eth?: string;
+  };
+}
+
+let infoCache: InfoCache = new Map();
+
+export const clearInfoCache = () => {
+  infoCache.clear();
+};
+export const getUserInfo = async (
+  key: string,
+  clientAddress?: string,
+): Promise<UserInfo | null> => {
+  let data: UserInfo = infoCache.get(key) || {
+    ensDomain: undefined,
+    address: undefined,
+    converseUsername: undefined,
+    ensInfo: undefined,
+  };
+  //console.log("Getting user info", key, clientAddress);
+  if (isAddress(clientAddress || "")) {
+    data.address = clientAddress;
+  } else if (isAddress(key || "")) {
+    data.address = key;
+  } else if (key.includes(".eth")) {
+    data.ensDomain = key;
+  } else if (key == "@user" || key == "@me" || key == "@bot") {
+    data.address = clientAddress;
+    data.ensDomain = key.replace("@", "") + ".eth";
+    data.converseUsername = key.replace("@", "");
+  } else if (key == "@alix") {
+    data.address = "0x3a044b218BaE80E5b9E16609443A192129A67BeA";
+    data.converseUsername = "alix";
+  } else if (key == "@bo") {
+    data.address = "0xbc3246461ab5e1682baE48fa95172CDf0689201a";
+    data.converseUsername = "bo";
+  } else {
+    data.converseUsername = key;
+  }
+
+  let keyToUse = data.address || data.ensDomain || data.converseUsername;
+  let cacheData = keyToUse && infoCache.get(keyToUse);
+  if (cacheData) {
+    //console.log("Getting user info", keyToUse, cacheData);
+    return cacheData;
+  } else {
+    //console.log("Getting user info", keyToUse, data);
+  }
+
+  if (keyToUse?.includes(".eth")) {
+    const response = await fetch(`https://ensdata.net/${keyToUse}`);
+    const ensData: EnsData = (await response.json()) as EnsData;
+    //console.log("Ens data", ensData);
+    if (ensData) {
+      data.ensInfo = ensData;
+      data.ensDomain = ensData?.ens;
+      data.address = ensData?.address;
+    }
+  } else if (keyToUse) {
+    keyToUse = keyToUse.replace("@", "");
+    const response = await fetch(`${converseEndpointURL}/profile/${keyToUse}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: JSON.stringify({
+        peer: keyToUse,
+      }),
+    });
+    const converseData = (await response.json()) as ConverseProfile;
+    if (process.env.MSG_LOG)
+      console.log("Converse data", keyToUse, converseData);
+    data.converseUsername =
+      converseData?.formattedName || converseData?.name || undefined;
+    data.address = converseData?.address || undefined;
+    data.avatar = converseData?.avatar || undefined;
+  }
+  if (data.address) infoCache.set(data.address, data);
+  return data;
+};
+export const isOnXMTP = async (
+  client: Client,
+  domain: string | undefined,
+  address: string | undefined,
+) => {
+  if (domain == "fabri.eth") return false;
+  if (address) return (await client.canMessage([address])).length > 0;
+};

package/templates/agent/src/prompt.ts

@@ -0,0 +1,81 @@
+export async function ens_agent_prompt(
+  address: string,
+  domain?: string,
+  name?: string,
+  converseUsername?: string,
+  txUrl?: string,
+) {
+  const systemPrompt = `You are a helpful and playful agent that lives inside a web3 messaging app called Converse.
+- You can respond with multiple messages if needed. Each message should be separated by a newline character.
+- You can trigger commands by only sending the command in a newline message.
+- Never announce actions without using a command separated by a newline character.
+- Only provide answers based on verified information.
+- Dont answer in markdown format, just answer in plaintext.
+- Do not make guesses or assumptions
+- CHECK that you are not missing a command
+
+User context: 
+- Users address is: ${address}
+${domain != undefined ? `- User ENS domain is: ${domain}` : ""}
+${name != undefined ? `- Converse username is: ${name}` : ""}
+
+## Task
+- Start by fetch their domain from or Convese username
+- Call the user by their name or domain, in case they have one
+- Ask for a name (if they don't have one) so you can suggest domains.
+
+Commands:
+- "/info [domain]": To get information about a domain use this command.
+- "/check [domain]": To check to see if a domain is available use this command.
+- "/register [domain]": To register a domain use this command. This will return a url pointing to the registration page.
+- "/renew [domain]": To trigger renewal of a domain use this command. This will return a url with a button to renew the domain.
+- "/tip [address]": To tip a domain or address use this command. This will return a url with a button to send the tip
+- "/cool [domain]": To get cool alternatives for a .eth domain use this command.
+
+Examples:
+- /check ${domain}
+- /info nick.eth
+- /register vitalik.eth 
+- /renew fabri.base.eth
+- /tip 0xf0EA7663233F99D0c12370671abBb6Cca980a490
+- /cool vitalik.eth
+
+## Example response:
+
+1. Check if the user does not have a ENS domain
+  Hey ${name}! it looks like you don't have a ENS domain yet! \n\Let me start by checking your Converse username ${converseUsername}.eth\n/check ${converseUsername}.eth
+
+2. If the user has a ENS domain
+  Hello ${domain} ! I'll help you get your ENS domain.\n Let's start by checking your ENS domain ${domain}. Give me a moment.\n/check ${domain}
+
+3. Check if the ENS domain is available
+  Hello! I'll help you get your domain.\n Let's start by checking your ENS domain ${domain}. Give me a moment.\n/check ${domain}
+
+4. If the ENS domain is available,
+  Looks like ${domain} is available! Would you like to register it?\n/register ${domain}\n or I can suggest some cool alternatives? Le me know!
+
+5. If the ENS domain is already registered, let me suggest 5 cool alternatives
+  Looks like ${domain} is already registered!\n What about these cool alternatives?\n/cool ${domain}
+
+6. If the user wants to register a ENS domain, use the command "/register [domain]"
+  Looks like ${domain} is available! Let me help you register it\n/register ${domain} 
+  
+7. If the user wants to directly to tip to the ENS domain owner, use directly the command "/tip [domain]", this will return a url but a button to send the tip 
+  Here is the url to send the tip:\n/tip ${domain}
+
+8. If the user wants to get information about the ENS domain, use the command "/info [domain]"
+  Hello! I'll help you get info about ${domain}.\n Give me a moment.\n/info ${domain}  
+
+9. If the user wants to renew their domain, use the command "/renew [domain]"
+  Hello! I'll help you get your ENS domain.\n Let's start by checking your ENS domain ${domain}. Give me a moment.\n/renew ${domain} 
+
+10. If the user wants cool suggestions about a domain, use the command "/cool [domain]"
+  Here are some cool suggestions for your domain.\n/cool ${domain}
+
+## Most common bug
+Some times you will say something like: "Looks like vitalik.eth is registered! What about these cool alternatives?"
+But you forgot to add the command at the end of the message.
+You should have said something like: "Looks like vitalik.eth is registered! What about these cool alternatives?\n/cool vitalik.eth
+`;
+  return systemPrompt;
+}

package/templates/agent/src/skills.ts

@@ -0,0 +1,93 @@
+import type { SkillGroup } from "@xmtp/message-kit";
+import { handleEns } from "./handler/ens.js";
+
+export const skills: SkillGroup[] = [
+  {
+    name: "Ens Domain Bot",
+    description: "Register ENS domains.",
+    skills: [
+      {
+        command: "/register [domain]",
+        triggers: ["/register", "@ensbot"],
+        handler: handleEns,
+        description:
+          "Register a new ENS domain. Returns a URL to complete the registration process.",
+        example: "/register vitalik.eth",
+        params: {
+          domain: {
+            type: "string",
+          },
+        },
+      },
+      {
+        command: "/info [domain]",
+        triggers: ["/info", "@ensbot"],
+        handler: handleEns,
+        description:
+          "Get detailed information about an ENS domain including owner, expiry date, and resolver.",
+        example: "/info nick.eth",
+        params: {
+          domain: {
+            type: "string",
+          },
+        },
+      },
+      {
+        command: "/renew [domain]",
+        triggers: ["/renew", "@ensbot"],
+        handler: handleEns,
+        description:
+          "Extend the registration period of your ENS domain. Returns a URL to complete the renewal.",
+        example: "/renew fabri.base.eth",
+        params: {
+          domain: {
+            type: "string",
+          },
+        },
+      },
+      {
+        command: "/check [domain] [cool_alternatives]",
+        triggers: ["/check"],
+        handler: handleEns,
+        description: "Check if a domain is available.",
+        params: {
+          domain: {
+            type: "string",
+          },
+          cool_alternatives: {
+            type: "quoted",
+          },
+        },
+      },
+      {
+        command: "/cool [domain]",
+        triggers: ["/cool"],
+        handler: handleEns,
+        description: "Get cool alternatives for a .eth domain.",
+        params: {
+          domain: {
+            type: "string",
+          },
+        },
+      },
+      {
+        command: "/reset",
+        triggers: ["/reset"],
+        handler: handleEns,
+        description: "Reset the conversation.",
+        params: {},
+      },
+      {
+        command: "/tip [address]",
+        description: "Show a URL for tipping a domain owner.",
+        triggers: ["/tip"],
+        handler: handleEns,
+        params: {
+          address: {
+            type: "string",
+          },
+        },
+      },
+    ],
+  },
+];

package/templates/gm/.env.example

@@ -0,0 +1 @@
+KEY= # the private key of the bot wallet