create-message-kit 1.2.4 → 1.2.8

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

@@ -1,7 +1,7 @@
 import { XMTPContext } from "@xmtp/message-kit";
 import type { Skill } from "@xmtp/message-kit";
 
-export const registerSkill: Skill[] = [
+export const token: Skill[] = [
   {
     skill: "/token [symbol]",
     handler: handler,

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

@@ -0,0 +1,97 @@
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+export const wordle: Skill[] = [
+  {
+    skill: "/wordle",
+    handler: handler,
+    examples: ["/wordle"],
+    description: "Play wordle.",
+    params: {},
+  },
+  {
+    skill: "/arena [word count] [audience size]",
+    examples: ["/arena 3 15"],
+    handler: handler,
+    description: "Play arena.",
+    params: {
+      wordCount: {
+        default: 3,
+        type: "number",
+      },
+      audienceSize: {
+        default: 15,
+        type: "number",
+      },
+    },
+  },
+];
+
+async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: { skill },
+    },
+  } = context;
+
+  if (skill === "arena") {
+    await handleArenaMessage(context);
+  } else if (skill === "wordle") {
+    await context.send("https://framedl.xyz");
+  } else if (skill === "help") {
+    await context.send(
+      "For using this bot you can use the following commands:\n\n" +
+        "/wordle, @wordle, 🔍, 🔎 - To start the game\n" +
+        "/arena <word count> <audience size> - To start the arena game\n" +
+        "/help - To see commands",
+    );
+  }
+}
+async function handleArenaMessage(context: XMTPContext) {
+  const {
+    message: {
+      content: { text },
+    },
+    members,
+  } = context;
+
+  const apiKey = process.env.FRAMEDL_API_KEY;
+  if (!apiKey) {
+    console.log("FRAMEDL_API_KEY is not set");
+    await context.send("https://www.framedl.xyz/games/arena/create");
+    return;
+  }
+  const participantCount = members && members.length ? members.length - 1 : 0;
+  const args = text?.split(" ") ?? [];
+  const wordCountArg = args[1] ? parseInt(args[1], 10) : 3;
+  const audienceSizeArg = args[2] ? parseInt(args[2], 10) : participantCount;
+  if (isNaN(wordCountArg) || isNaN(audienceSizeArg)) {
+    await context.send(
+      "usage: /arena <word count> <audience size>\n\n" +
+        "word count: number of words in the arena (default: 3, min: 1, max: 9)\n" +
+        "audience size: number of audience members (default: number of participants excluding wordle bot, min: 1, max: 15)",
+    );
+    return;
+  }
+
+  const audienceSize = Math.max(1, Math.min(15, audienceSizeArg));
+  const wordCount = Math.max(1, Math.min(9, wordCountArg));
+
+  try {
+    const response = await fetch("https://www.framedl.xyz/api/arenas", {
+      method: "POST",
+      body: JSON.stringify({ wordCount, audienceSize }),
+      headers: {
+        "Content-Type": "application/json",
+        "x-framedl-api-key": apiKey,
+      },
+    });
+
+    const data = (await response.json()) as { arenaUrl: string };
+
+    await context.send(data.arenaUrl);
+  } catch (error) {
+    console.error(error);
+    await context.send("https://www.framedl.xyz/games/arena/create");
+  }
+}

package/templates/gpt/.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/gpt/src/index.ts

@@ -7,6 +7,7 @@ import {
 } from "@xmtp/message-kit";
 
 import { systemPrompt } from "./prompt.js";
+
 export const agent: Agent = {
   name: "GPT Bot",
   tag: "@bot",

package/templates/agent/src/handlers/game.ts

@@ -1,58 +0,0 @@
-import { XMTPContext } from "@xmtp/message-kit";
-import type { Skill } from "@xmtp/message-kit";
-
-export const registerSkill: Skill[] = [
-  {
-    skill: "/game [game]",
-    handler: handler,
-    description: "Play a game.",
-    examples: ["/game wordle", "/game slot", "/game help"],
-    params: {
-      game: {
-        default: "",
-        type: "string",
-        values: ["wordle", "slot", "help"],
-      },
-    },
-  },
-];
-
-export async function handler(context: XMTPContext) {
-  const {
-    message: {
-      content: { skill, params, text },
-    },
-  } = context;
-  if (!skill) {
-    if (text === "🔎" || text === "🔍") {
-      // Send the URL for the requested game
-      context.reply("https://framedl.xyz/");
-    }
-    return;
-  }
-  // URLs for each game type
-  const gameUrls: { [key: string]: string } = {
-    wordle: "https://framedl.xyz",
-    slot: "https://slot-machine-frame.vercel.app",
-  };
-  let returnText = "";
-  switch (params.game) {
-    case "wordle":
-    case "slot":
-      // Retrieve the URL for the requested game using a simplified variable assignment
-      const gameUrl = gameUrls[params.game];
-      // Send the URL for the requested game
-      returnText = gameUrl;
-      break;
-
-    case "help":
-      returnText = "Available games: \n/game wordle\n/game slot";
-      break;
-    default:
-      // Inform the user about unrecognized skills and provide available options
-      returnText =
-        "Skill not recognized. Available games: wordle, slot, or help.";
-      break;
-  }
-  return { code: 200, message: returnText };
-}

package/templates/agent/src/handlers/reset.ts

@@ -1,19 +0,0 @@
-import { clearInfoCache, clearMemory } from "@xmtp/message-kit";
-import { XMTPContext } from "@xmtp/message-kit";
-
-import type { Skill } from "@xmtp/message-kit";
-
-export const registerSkill: Skill[] = [
-  {
-    skill: "/reset",
-    examples: ["/reset"],
-    handler: handler,
-    description: "Reset the conversation.",
-    params: {},
-  },
-];
-export async function handler(context: XMTPContext) {
-  clearMemory();
-  clearInfoCache();
-  return { code: 200, message: "Conversation reset." };
-}

package/templates/gated/.env.example

@@ -1,3 +0,0 @@
-KEY= # the private key of the bot wallet
-PORT= # the port of the server
-ALCHEMY_API_KEY= # the alchemy api key

package/templates/gated/src/index.ts

@@ -1,64 +0,0 @@
-import { run, xmtpClient, XMTPContext } from "@xmtp/message-kit";
-import { Client } from "@xmtp/node-sdk";
-import { startServer } from "./lib/gated.js";
-import { verifiedRequest } from "./lib/nft.js";
-const { client } = await xmtpClient({ hideInitLogMessage: true });
-startServer(client, verifiedRequest);
-
-run(async (context: XMTPContext) => {
-  const {
-    message: {
-      sender,
-      content: { skill },
-    },
-    client,
-    group,
-  } = context;
-
-  if (skill == "id") {
-    console.log(group?.id);
-  } else if (skill === "create") {
-    await context.send("Creating group...");
-    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!",
-    );
-  }
-});
-
-async function createGroup(
-  client: Client,
-  senderAddress: string,
-  clientAddress: string,
-) {
-  let senderInboxId = "";
-  const group = await client?.conversations.newGroup([
-    senderAddress,
-    clientAddress,
-  ]);
-  const members = await group.members();
-  const senderMember = members.find((member) =>
-    member.accountAddresses.includes(senderAddress.toLowerCase()),
-  );
-  if (senderMember) {
-    const 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;
-}

package/templates/gated/src/lib/gated.ts

@@ -1,51 +0,0 @@
-// Import necessary modules
-import express from "express";
-import { Client } from "@xmtp/node-sdk";
-
-export function startServer(
-  client: Client,
-  verifiedRequest: (walletAddress: string, groupId: string) => Promise<boolean>,
-) {
-  async function addWalletToGroup(
-    walletAddress: string,
-    groupId: string,
-  ): Promise<string> {
-    const conversation =
-      await client.conversations.getConversationById(groupId);
-    const verified = await verifiedRequest(walletAddress, groupId);
-    if (!verified) {
-      console.log("User cant be added to the group");
-      return "not verified";
-    } else {
-      try {
-        await conversation?.addMembers([walletAddress]);
-        console.log(`Added wallet address: ${walletAddress} to the group`);
-        return "success";
-      } 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 server
-  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/gated/src/skills.ts

@@ -1,23 +0,0 @@
-import type { Agent } from "@xmtp/message-kit";
-
-export const agent: Agent = {
-  name: "Group Id",
-  tag: "@bot",
-  description: "Create and get group id.",
-  skills: [
-    {
-      skill: "/create",
-      examples: ["/create"],
-      adminOnly: true,
-      params: {},
-      description: "Create a new group.",
-    },
-    {
-      skill: "/id",
-      examples: ["/id"],
-      adminOnly: true,
-      params: {},
-      description: "Get group id.",
-    },
-  ],
-};