create-message-kit 1.2.4 → 1.2.8

package/templates/experimental/.cursorrules

@@ -0,0 +1,227 @@
+# MessageKit Skill Template
+
+## Examples
+
+### Check if a Domain is Available
+
+```typescript
+import { ensUrl } from "../index.js";
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+// Define Skill
+export const checkDomain: Skill[] = [
+  {
+    skill: "/check [domain]",
+    handler: handler,
+    examples: ["/check vitalik.eth", "/check fabri.base.eth"],
+    description: "Check if a domain is available.",
+    params: {
+      domain: {
+        type: "string",
+      },
+    },
+  },
+];
+
+// Handler Implementation
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { domain },
+      },
+    },
+  } = context;
+
+  const data = await context.getUserInfo(domain);
+
+  if (!data?.address) {
+    let message = `Looks like ${domain} is available! Here you can 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.executeSkill("/cool " + domain);
+    return {
+      code: 404,
+      message,
+    };
+  }
+}
+
+### Generate a payment request
+
+```typescript
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+// Define Skill
+export const paymentRequest: Skill[] = [
+  {
+    skill: "/pay [amount] [token] [username] [address]",
+    examples: [
+      "/pay 10 vitalik.eth",
+      "/pay 1 usdc to 0xc9925662D36DE3e1bF0fD64e779B2e5F0Aead964",
+    ],
+    description:
+      "Send a specified amount of a cryptocurrency to a destination address. \nWhen tipping, you can assume it's 1 USDC.",
+    handler: handler,
+    params: {
+      amount: {
+        default: 10,
+        type: "number",
+      },
+      token: {
+        default: "usdc",
+        type: "string",
+        values: ["eth", "dai", "usdc", "degen"], // Accepted tokens
+      },
+      username: {
+        default: "",
+        type: "username",
+      },
+      address: {
+        default: "",
+        type: "address",
+      },
+    },
+  },
+];
+
+// Handler Implementation
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { amount, token, username, address },
+      },
+    },
+  } = context;
+  let receiverAddress = address;
+  if (username) {
+    receiverAddress = (await context.getUserInfo(username))?.address;
+  }
+  if (address) {
+    // Prioritize address over username
+    receiverAddress = address;
+  }
+
+  await context.requestPayment(amount, token, receiverAddress);
+}
+```
+
+
+## Types
+
+```typescript
+import { XMTPContext } from "../lib/xmtp.js";
+import { ClientOptions, GroupMember } from "@xmtp/node-sdk";
+import { ContentTypeId } from "@xmtp/content-type-primitives";
+
+export type MessageAbstracted = {
+  id: string;
+  sent: Date;
+  content: {
+    text?: string | undefined;
+    reply?: string | undefined;
+    previousMsg?: string | undefined;
+    react?: string | undefined;
+    content?: any | undefined;
+    params?: any | undefined;
+    reference?: string | undefined;
+    skill?: string | undefined;
+  };
+  version: "v2" | "v3";
+  sender: AbstractedMember;
+  typeId: string;
+};
+export type GroupAbstracted = {
+  id: string;
+  sync: () => Promise<void>;
+  addMembers: (addresses: string[]) => Promise<void>;
+  addMembersByInboxId: (inboxIds: string[]) => Promise<void>;
+  send: (content: string, contentType?: ContentTypeId) => Promise<string>;
+  isAdmin: (inboxId: string) => boolean;
+  isSuperAdmin: (inboxId: string) => boolean;
+  admins: string[];
+  superAdmins: string[];
+  createdAt: Date;
+  members: GroupMember[];
+};
+export type SkillResponse = {
+  code: number;
+  message: string;
+  data?: any;
+};
+
+export type SkillHandler = (
+  context: XMTPContext,
+) => Promise<SkillResponse | void>;
+
+export type Handler = (context: XMTPContext) => Promise<void>;
+
+export type RunConfig = {
+  // client options from XMTP client
+  client?: ClientOptions;
+  // private key to be used for the client, if not, default from env
+  privateKey?: string;
+  // if true, the init log message with messagekit logo and stuff will be hidden
+  experimental?: boolean;
+  // hide the init log message with messagekit logo and stuff
+  hideInitLogMessage?: boolean;
+  // if true, attachments will be enabled
+  attachments?: boolean;
+  // if true, member changes will be enabled, like adding members to the group
+  memberChange?: boolean;
+  // skills to be used
+  agent?: Agent;
+  // model to be used
+  gptModel?: string;
+};
+export interface SkillParamConfig {
+  default?: string | number | boolean;
+  type:
+    | "number"
+    | "string"
+    | "username"
+    | "quoted"
+    | "address"
+    | "prompt"
+    | "url";
+  plural?: boolean;
+  values?: string[]; // Accepted values for the parameter
+}
+
+export interface Frame {
+  title: string;
+  buttons: { content: string; action: string; target: string }[];
+  image: string;
+}
+export interface Agent {
+  name: string;
+  description: string;
+  tag: string;
+  skills: Skill[];
+}
+export interface Skill {
+  skill: string;
+  handler?: SkillHandler | undefined;
+  adminOnly?: boolean;
+  description: string;
+  examples: string[];
+  params: Record<string, SkillParamConfig>;
+}
+
+export interface AbstractedMember {
+  inboxId: string;
+  address: string;
+  accountAddresses: string[];
+  installationIds?: string[];
+}
+
+export type MetadataValue = string | number | boolean;
+export type Metadata = Record<string, MetadataValue | MetadataValue[]>;
+```

package/templates/experimental/.env.example

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

package/templates/{gated → experimental}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "gated",
+  "name": "experimental",
   "private": true,
   "type": "module",
   "scripts": {
@@ -9,11 +9,13 @@
   },
   "dependencies": {
     "@xmtp/message-kit": "workspace:*",
-    "alchemy-sdk": "^3.4.3",
-    "express": "^4.19.2"
+    "alchemy-sdk": "^3.0.0",
+    "express": "^4.19.2",
+    "node-fetch": "^3.3.2",
+    "resend": "^4.0.1"
   },
   "devDependencies": {
-    "@types/express": "^4",
+    "@types/express": "^4.17.20",
     "@types/node": "^20.14.2",
     "typescript": "^5.4.5"
   },

package/templates/experimental/src/index.ts

@@ -0,0 +1,53 @@
+import {
+  run,
+  agentReply,
+  replaceVariables,
+  XMTPContext,
+  Agent,
+  xmtpClient,
+  V3Client,
+} from "@xmtp/message-kit";
+import fs from "fs";
+import { systemPrompt } from "./prompt.js";
+import { token } from "./skills/token.js";
+import { todo } from "./skills/todo.js";
+import { gated, startGatedGroupServer } from "./skills/gated.js";
+import { broadcast } from "./skills/broadcast.js";
+import { wordle } from "./skills/wordle.js";
+
+export const agent: Agent = {
+  name: "Experimental Agent",
+  tag: "@bot",
+  description: "An experimental agent with a lot of skills.",
+  skills: [
+    ...token,
+    ...(process?.env?.RESEND_API_KEY ? todo : []),
+    ...(process?.env?.ALCHEMY_SDK ? gated : []),
+    ...broadcast,
+    ...wordle,
+  ],
+};
+
+// [!region gated]
+const { client } = await xmtpClient({
+  hideInitLogMessage: true,
+});
+
+startGatedGroupServer(client);
+// [!endregion gated]
+
+run(
+  async (context: XMTPContext) => {
+    const {
+      message: { sender },
+      agent,
+    } = context;
+
+    let prompt = await replaceVariables(systemPrompt, sender.address, agent);
+
+    //This is only used for to update the docs.
+    fs.writeFileSync("example_prompt.md", prompt);
+    await agentReply(context, prompt);
+  },
+  { agent },
+);

package/templates/{gated/src/lib/nft.ts → experimental/src/lib/alchemy.ts}

@@ -5,28 +5,22 @@ const settings = {
   network: Network.BASE_MAINNET, // Use the appropriate network
 };
 
-export async function verifiedRequest(
+export async function checkNft(
   walletAddress: string,
-  groupId: string
+  collectionSlug: string,
 ): Promise<boolean> {
-  console.log("new-request", {
-    groupId,
-    walletAddress,
-  });
-
   const alchemy = new Alchemy(settings);
   try {
     const nfts = await alchemy.nft.getNftsForOwner(walletAddress);
-    const collectionSlug = "XMTPeople"; // The slug for the collection
 
     const ownsNft = nfts.ownedNfts.some(
       (nft: any) =>
-        nft.contract.name.toLowerCase() === collectionSlug.toLowerCase()
-    );
-    console.log(
-      `NFTs owned on ${Network.BASE_MAINNET}:`,
-      nfts.ownedNfts.length
+        nft.contract.name.toLowerCase() === collectionSlug.toLowerCase(),
     );
+    // console.log(
+    //   `NFTs owned on ${Network.BASE_MAINNET}:`,
+    //   nfts.ownedNfts.length,
+    // );
     console.log("is the nft owned: ", ownsNft);
     return ownsNft as boolean;
   } catch (error) {

package/templates/experimental/src/lib/minilog.ts

@@ -0,0 +1,26 @@
+import fetch from "node-fetch";
+
+export async function sendLog(title: string, description: string) {
+  const response = await fetch("https://api.minilog.dev/v1/logs/testlog", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: "Bearer pthsm38sccpux5acriqish7isz5inet7q73ef7br",
+    },
+    body: JSON.stringify({
+      application: "myapp-1",
+      severity: "DEBUG",
+      data: title,
+      metadata: {
+        title,
+        description,
+      },
+    }),
+  });
+  console.log(response);
+  if (!response.ok) {
+    console.error("Failed to send log:", response.statusText);
+  } else {
+    console.log("Log sent successfully");
+  }
+}

package/templates/experimental/src/lib/xmtp.ts

@@ -0,0 +1,136 @@
+import { isOnXMTP, V3Client, V2Client } from "@xmtp/message-kit";
+
+export async function createGroup(
+  client: V3Client,
+  senderAddress: string,
+  clientAddress: string,
+) {
+  try {
+    let senderInboxId = "";
+    await client.conversations.sync();
+    const conversations = await client.conversations.list();
+    console.log("Conversations", conversations.length);
+    const group = await client?.conversations.newGroup([
+      senderAddress,
+      clientAddress,
+    ]);
+    console.log("Group created", group?.id);
+    const members = await group.members();
+    const senderMember = members.find((member) =>
+      member.accountAddresses.includes(senderAddress.toLowerCase()),
+    );
+    if (senderMember) {
+      senderInboxId = senderMember.inboxId;
+      console.log("Sender's inboxId:", senderInboxId);
+    } else {
+      console.log("Sender not found in members list");
+    }
+    await group.addSuperAdmin(senderInboxId);
+    console.log(
+      "Sender is superAdmin",
+      await group.isSuperAdmin(senderInboxId),
+    );
+    await group.send(`Welcome to the new group!`);
+    await group.send(`You are now the admin of this group as well as the bot`);
+    return group;
+  } catch (error) {
+    console.log("Error creating group", error);
+    return null;
+  }
+}
+
+export async function removeFromGroup(
+  groupId: string,
+  client: V3Client,
+  v2client: V2Client,
+  senderAddress: string,
+): Promise<{ code: number; message: string }> {
+  try {
+    let lowerAddress = senderAddress.toLowerCase();
+    const { v2, v3 } = await isOnXMTP(client, v2client, lowerAddress);
+    console.warn("Checking if on XMTP: v2", v2, "v3", v3);
+    if (!v3)
+      return {
+        code: 400,
+        message: "You don't seem to have a v3 identity ",
+      };
+    const conversation =
+      await client.conversations.getConversationById(groupId);
+    console.warn("removing from group", conversation?.id);
+    await conversation?.sync();
+    await conversation?.removeMembers([lowerAddress]);
+    console.warn("Removed member from group");
+    await conversation?.sync();
+    const members = await conversation?.members();
+    console.warn("Number of members", members?.length);
+
+    let wasRemoved = true;
+    if (members) {
+      for (const member of members) {
+        let lowerMemberAddress = member.accountAddresses[0].toLowerCase();
+        if (lowerMemberAddress === lowerAddress) {
+          wasRemoved = false;
+          break;
+        }
+      }
+    }
+    return {
+      code: wasRemoved ? 200 : 400,
+      message: wasRemoved
+        ? "You have been removed from the group"
+        : "Failed to remove from group",
+    };
+  } catch (error) {
+    console.log("Error removing from group", error);
+    return {
+      code: 400,
+      message: "Failed to remove from group",
+    };
+  }
+}
+export async function addToGroup(
+  groupId: string,
+  client: V3Client,
+  address: string,
+): Promise<{ code: number; message: string }> {
+  try {
+    let lowerAddress = address.toLowerCase();
+    const { v2, v3 } = await isOnXMTP(client, null, lowerAddress);
+    if (!v3)
+      return {
+        code: 400,
+        message: "You don't seem to have a v3 identity ",
+      };
+    const group = await client.conversations.getConversationById(groupId);
+    console.warn("Adding to group", group?.id);
+    await group?.sync();
+    //DON'T TOUCH THIS LINE
+    await group?.addMembers([lowerAddress]);
+    console.warn("Added member to group");
+    await group?.sync();
+    const members = await group?.members();
+    console.warn("Number of members", members?.length);
+
+    if (members) {
+      for (const member of members) {
+        let lowerMemberAddress = member.accountAddresses[0].toLowerCase();
+        if (lowerMemberAddress === lowerAddress) {
+          console.warn("Member exists", lowerMemberAddress);
+          return {
+            code: 200,
+            message: "You have been added to the group",
+          };
+        }
+      }
+    }
+    return {
+      code: 400,
+      message: "Failed to add to group",
+    };
+  } catch (error) {
+    return {
+      code: 400,
+      message: "Failed to add to group",
+    };
+  }
+}

package/templates/experimental/src/prompt.ts

@@ -0,0 +1,24 @@
+export const systemPrompt = `
+Your are helpful and playful experimental agent called {agent_name} that lives inside a messaging app called Converse.
+
+{rules}
+
+{user_context}
+
+{skills}
+
+## Scenarios
+1. Missing commands in responses
+   **Issue**: Sometimes responses are sent without the required command.
+   **Example**:
+   Incorrect:
+   > "Looks like vitalik.eth is registered! What about these cool alternatives?"
+   Correct:
+   > "Looks like vitalik.eth is registered! What about these cool alternatives?
+   > /cool vitalik.eth"
+
+   Incorrect:
+   > Here is a summary of your TODOs. I will now send it via email.
+   Correct:
+   > /todo
+`;

package/templates/experimental/src/skills/broadcast.ts

@@ -0,0 +1,39 @@
+import { XMTPContext, Skill } from "@xmtp/message-kit";
+
+export const broadcast: Skill[] = [
+  {
+    skill: "/send",
+    adminOnly: true,
+    handler: handler,
+    examples: ["/send Hello everyone, the event is starting now!"],
+    description: "Send updates to all subscribers.",
+    params: {
+      message: {
+        type: "prompt",
+      },
+    },
+  },
+];
+
+async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { message },
+      },
+    },
+  } = context;
+
+  const fakeSubscribers = ["0x93E2fc3e99dFb1238eB9e0eF2580EFC5809C7204"];
+  await context.send("This is how your message will look like:");
+  await context.send(message);
+  const emailResponse = await context.awaitResponse(
+    "Are you sure you want to send this broadcast?\nType 'yes' to confirm.",
+    ["yes", "no"],
+  );
+  if (emailResponse === "yes") {
+    await context.send("Sending broadcast...");
+    await context.sendTo(message, fakeSubscribers);
+    await context.send("Broadcast sent!");
+  }
+}

package/templates/experimental/src/skills/gated.ts

@@ -0,0 +1,89 @@
+import { XMTPContext, Skill, V3Client } from "@xmtp/message-kit";
+import { createGroup } from "../lib/xmtp.js";
+import express from "express";
+import { checkNft } from "../lib/alchemy.js";
+import { addToGroup } from "../lib/xmtp.js";
+export const gated: Skill[] = [
+  {
+    skill: "/create",
+    examples: ["/create"],
+    handler: handler,
+    adminOnly: true,
+    params: {},
+    description: "Create a new group.",
+  },
+];
+
+async function handler(context: XMTPContext) {
+  const {
+    message: {
+      sender,
+      content: { skill },
+    },
+    client,
+  } = context;
+
+  if (skill === "create") {
+    const group = await createGroup(
+      client,
+      sender.address,
+      client.accountAddress,
+    );
+
+    await context.send(
+      `Group created!\n- ID: ${group?.id}\n- Group Frame URL: https://converse.xyz/group/${group?.id}: \n- This url will deelink to the group inside Converse\n- Once in the other group you can share the invite with your friends.`,
+    );
+    return;
+  } else {
+    await context.send(
+      "👋 Welcome to the Gated Bot Group!\nTo get started, type /create to set up a new group. 🚀\nThis example will check if the user has a particular nft and add them to the group if they do.\nOnce your group is created, you'll receive a unique Group ID and URL.\nShare the URL with friends to invite them to join your group!",
+    );
+  }
+}
+
+export function startGatedGroupServer(client: V3Client) {
+  async function addWalletToGroup(
+    walletAddress: string,
+    groupId: string,
+  ): Promise<string> {
+    const verified = true; //await checkNft(walletAddress, "XMTPeople");
+    if (!verified) {
+      console.log("User cant be added to the group");
+      return "not verified";
+    } else {
+      try {
+        const added = await addToGroup(groupId, client, walletAddress);
+        if (added.code === 200) {
+          console.log(`Added wallet address: ${walletAddress} to the group`);
+          return "success";
+        } else {
+          return added.message;
+        }
+      } catch (error: any) {
+        console.log(error.message);
+        return "error";
+      }
+    }
+  }
+
+  // Endpoint to add wallet address to a group from an external source
+  const app = express();
+  app.use(express.json());
+  app.post("/add-wallet", async (req, res) => {
+    try {
+      const { walletAddress, groupId } = req.body;
+      const result = await addWalletToGroup(walletAddress, groupId);
+      res.status(200).send(result);
+    } catch (error: any) {
+      res.status(400).send(error.message);
+    }
+  });
+  // Start the servfalcheer
+  const PORT = process.env.PORT || 3000;
+  const url = process.env.URL || `http://localhost:${PORT}`;
+  app.listen(PORT, () => {
+    console.warn(
+      `Use this endpoint to add a wallet to a group indicated by the groupId\n${url}/add-wallet <body: {walletAddress, groupId}>`,
+    );
+  });
+}

package/templates/{agent/src/handlers → experimental/src/skills}/todo.ts

@@ -4,7 +4,7 @@ import type { Skill } from "@xmtp/message-kit";
 
 const resend = new Resend(process.env.RESEND_API_KEY); // Replace with your Resend API key
 
-export const registerSkill: Skill[] = [
+export const todo: Skill[] = [
   {
     skill: "/todo",
     handler: handler,
@@ -30,7 +30,7 @@ export async function handler(context: XMTPContext) {
   let intents = 2;
   while (intents > 0) {
     const emailResponse = await context.awaitResponse(
-      "Please provide your email address to receive the TODO summary:",
+      "Please provide your email address to receive the to-dos summary:",
     );
     email = emailResponse;
 
@@ -52,14 +52,20 @@ export async function handler(context: XMTPContext) {
     return;
   }
   try {
-    if (typeof previousMsg === "string") {
+    let { reply } = await context.textGeneration(
+      email,
+      "Make this summary concise and to the point to be sent in an email.\n msg: " +
+        previousMsg,
+      "You are an expert at summarizing to-dos.  Return in format html and just the content inside the body tag. Dont return `html` or `body` tags",
+    );
+    if (typeof reply === "string") {
       let content = {
         from: "bot@mail.coin-toss.xyz",
         to: email,
         subject: "Your summary from Converse",
         html: `
-        <h3>Your TODO Summary</h3>
-        <p>${previousMsg.replace(/\n/g, "<br>")}</p>
+        <h3>Your Converse Summary</h3>
+        <p>${reply}</p>
       `,
       };
       await resend.emails.send(content);