create-message-kit 1.2.14 → 1.2.16

package/templates/playground/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/playground/src/skills/cash.ts

@@ -0,0 +1,122 @@
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+import { USDCWallet } from "../plugins/usdc.js";
+
+export const cash: Skill[] = [
+  {
+    skill: "balance",
+    handler: balanceHandler,
+    examples: ["/balance"],
+    description: "Check your balance.",
+  },
+  {
+    skill: "fund",
+    handler: fundHandler,
+    examples: ["/fund 1", "/fund 10"],
+    params: {
+      amount: {
+        type: "number",
+        default: "",
+      },
+    },
+    description: "Fund your wallet. Returns a url to fund your wallet.",
+  },
+  {
+    skill: "transfer",
+    handler: transferHandler,
+    examples: ["/transfer 0x40f08f0f853d1c42c61815652b7ccd5a50f0be09 1"],
+    params: {
+      address: {
+        type: "address",
+        default: "",
+      },
+      amount: {
+        type: "number",
+        default: "",
+      },
+    },
+    description: "Transfer USDC to another address.",
+  },
+];
+
+async function balanceHandler(context: XMTPContext) {
+  const {
+    message: { sender },
+  } = context;
+  const usdcWallet = new USDCWallet(sender.address);
+  const { usdc } = await usdcWallet.checkBalances();
+  await context.send(
+    `Your balance is ${usdc} USDC. let me know if you want check again or to fund your wallet.`,
+  );
+}
+
+async function fundHandler(context: XMTPContext) {
+  try {
+    const {
+      message: {
+        sender,
+        content: {
+          params: { amount },
+        },
+      },
+    } = context;
+    const usdcWallet = new USDCWallet(sender.address);
+    const { usdc } = await usdcWallet.checkBalances();
+    const MAX_USDC = 10;
+
+    if (usdc >= MAX_USDC) {
+      await context.send(`Your balance is maxed out at ${MAX_USDC} USDC.`);
+      return;
+    }
+
+    const remainingLimit = MAX_USDC - usdc;
+    let fundAmount: number;
+
+    if (!amount) {
+      const options = Array.from(
+        { length: Math.floor(remainingLimit) },
+        (_, i) => (i + 1).toString(),
+      );
+      const response = await context.awaitResponse(
+        `Please specify the amount of USDC to prefund (1 to ${remainingLimit}):`,
+        options,
+      );
+      fundAmount = parseInt(response);
+    } else {
+      fundAmount = parseInt(amount);
+    }
+
+    if (isNaN(fundAmount) || fundAmount <= 0 || fundAmount > remainingLimit) {
+      await context.send(
+        `Invalid amount. Please specify a value between 1 and ${remainingLimit} USDC.`,
+      );
+      return;
+    }
+
+    await context.requestPayment(fundAmount, "USDC", usdcWallet.agentAddress);
+    await context.send(
+      "After funding, let me know so I can check your balance.",
+    );
+  } catch (error) {
+    await context.send(
+      "An error occurred while processing your request. Please try again.",
+    );
+  }
+}
+
+async function transferHandler(context: XMTPContext) {
+  const {
+    message: {
+      sender,
+      content: {
+        params: { address, amount },
+      },
+    },
+  } = context;
+  const usdcWallet = new USDCWallet(sender.address);
+  if (amount > 10) {
+    await context.send("You can only transfer up to 10 USDC at a time.");
+    return;
+  }
+  await usdcWallet.transferUsdc(address, amount);
+}

package/templates/playground/src/skills/cryptoPrice.ts

@@ -0,0 +1,63 @@
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+// Example skill structure
+export const cryptoPrice: Skill[] = [
+  {
+    skill: "price", 
+    handler: handler,
+    examples: ["/price BTC USD", "/price ETH EUR"],
+    description: "Get the current exchange rate for a cryptocurrency.",
+    params: {
+      crypto: {
+        type: "string",
+      },
+      currency: {
+        type: "string",
+        default: "USD",
+      },
+    },
+  },
+];
+
+async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { crypto, currency },
+      },
+    },
+  } = context;
+
+  try {
+    const response = await fetch(
+      `https://min-api.cryptocompare.com/data/price?fsym=${crypto}&tsyms=${currency}`
+    );
+
+    if (!response.ok) {
+      return {
+        code: response.status,
+        message: `Unable to fetch exchange rate: ${response.statusText}`,
+      };
+    }
+
+    const data = await response.json() as Record<string, number>;
+    
+    if (!data[currency]) {
+      return {
+        code: 400,
+        message: `Could not find exchange rate for ${crypto}/${currency}`,
+      };
+    }
+
+    return {
+      code: 200,
+      message: `1 ${crypto} = ${data[currency]} ${currency}`,
+    };
+  } catch (error: any) {
+    return {
+      code: 500,
+      message: `Error fetching exchange rate: ${error.message}`,
+    };
+  }
+}

package/templates/playground/src/skills/dalle.ts

@@ -0,0 +1,61 @@
+import { XMTPContext } from "@xmtp/message-kit";
+
+import type { Skill } from "@xmtp/message-kit";
+import OpenAI from "openai";
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+export const dalle: Skill[] = [
+  {
+    skill: "image",
+    handler: handler,
+    description: "Generate an image based on a prompt.",
+    examples: ["/image dog with a ball"],
+    params: {
+      prompt: {
+        type: "prompt",
+      },
+    },
+  },
+];
+
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      sender,
+      content: {
+        params: { prompt },
+      },
+    },
+  } = context;
+
+  if (!prompt) {
+    return {
+      code: 400,
+      message: "Missing required parameters. Please provide a prompt.",
+    };
+  }
+
+  try {
+    const response = await openai.images.generate({
+      prompt: prompt,
+      n: 1,
+      size: "1024x1024",
+    });
+
+    const imageUrl = response.data[0].url;
+    console.log(imageUrl);
+    const message = `Here is the image generated for the prompt "${prompt}": ${imageUrl}`;
+    context.send(message);
+  } catch (error) {
+    // @ts-ignore
+    const message = `Failed to generate image. Error: ${error?.message}
+    }`;
+    return {
+      code: 500,
+      message,
+    };
+  }
+}

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

@@ -0,0 +1,88 @@
+import { XMTPContext, Skill, V3Client } from "@xmtp/message-kit";
+import { createGroup } from "../plugins/xmtp.js";
+import express from "express";
+import { checkNft } from "../plugins/alchemy.js";
+import { addToGroup } from "../plugins/xmtp.js";
+export const gated: Skill[] = [
+  {
+    skill: "create",
+    examples: ["/create"],
+    handler: handler,
+    adminOnly: true,
+    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 = 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/playground/src/skills/search.ts

@@ -0,0 +1,159 @@
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+import OpenAI from "openai";
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+export const search: Skill[] = [
+  {
+    skill: "search",
+    examples: [
+      "/search what is the capital of France?",
+      "/search latest news about ethereum",
+    ],
+    handler: handler,
+    description:
+      "Search the internet and get summarized information from top results.",
+    params: {
+      query: {
+        type: "prompt",
+      },
+    },
+  },
+];
+
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { query },
+      },
+    },
+  } = context;
+
+  try {
+    // Search and get top results
+    const searchResults = await searchDuckDuckGo(query);
+    if (!searchResults.length) {
+      return {
+        code: 404,
+        message: "No results found for your query.",
+      };
+    }
+
+    // Fetch content from each result
+    const contents = await Promise.all(
+      searchResults.slice(0, 3).map(async (url) => {
+        try {
+          const response = await fetch(url, {
+            headers: {
+              "User-Agent":
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+            },
+          });
+          const html = await response.text();
+          return extractContent(html);
+        } catch (error) {
+          console.error(`Error fetching ${url}:`, error);
+          return "";
+        }
+      }),
+    );
+
+    // Combine and summarize the content
+    const summary = await getAISummary(contents.join("\n"), query);
+
+    return {
+      code: 200,
+      message: summary,
+    };
+  } catch (error: any) {
+    return {
+      code: 500,
+      message: `Search failed: ${error.message}`,
+    };
+  }
+}
+
+async function searchDuckDuckGo(query: string): Promise<string[]> {
+  try {
+    // DuckDuckGo's lite version is more friendly to programmatic access
+    const response = await fetch(
+      `https://duckduckgo.com/lite?q=${encodeURIComponent(query)}`,
+      {
+        headers: {
+          "User-Agent":
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+        },
+      },
+    );
+
+    const html = await response.text();
+
+    // Extract URLs from the results
+    const urlRegex = /<a class="result-link" href="([^"]+)"/g;
+    const urls: string[] = [];
+    let match;
+
+    while ((match = urlRegex.exec(html)) !== null) {
+      if (match[1] && !match[1].includes("duckduckgo.com")) {
+        urls.push(match[1]);
+      }
+    }
+
+    // If no results from regex, try alternative pattern
+    if (urls.length === 0) {
+      const altRegex = /rel="nofollow" href="([^"]+)"/g;
+      while ((match = altRegex.exec(html)) !== null) {
+        if (match[1] && !match[1].includes("duckduckgo.com")) {
+          urls.push(match[1]);
+        }
+      }
+    }
+
+    return urls;
+  } catch (error) {
+    console.error("Search failed:", error);
+    return [];
+  }
+}
+
+function extractContent(html: string): string {
+  // Remove scripts and style elements
+  html = html
+    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "")
+    .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "");
+
+  // Get text content
+  const text = html
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, 2000); // Get more content for search results
+
+  return text;
+}
+
+async function getAISummary(content: string, query: string): Promise<string> {
+  const completion = await openai.chat.completions.create({
+    messages: [
+      {
+        role: "system",
+        content:
+          "You are a helpful assistant that provides clear, accurate summaries (2-3 sentences) of search results.",
+      },
+      {
+        role: "user",
+        content: `Based on the following search results, please provide a comprehensive answer to the query: "${query}"\n\nSearch results:\n${content}`,
+      },
+    ],
+    model: "gpt-4o-mini",
+  });
+
+  return (
+    completion.choices[0].message.content ||
+    "Could not generate a summary of the search results."
+  );
+}

package/templates/playground/src/skills/todo.ts

@@ -0,0 +1,79 @@
+import { Resend } from "resend";
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+const resend = new Resend(process.env.RESEND_API_KEY); // Replace with your Resend API key
+
+export const todo: Skill[] = [
+  {
+    skill: "todo",
+    handler: handler,
+    examples: ["/todo"],
+    description:
+      "Summarize your TODOs and send an email with the summary. Receives no parameters.",
+  },
+];
+
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: { previousMsg },
+    },
+  } = context;
+
+  let email = "";
+  if (!previousMsg) {
+    await context.send("You need to do it on a reply.");
+    return;
+  }
+  let intents = 2;
+  while (intents > 0) {
+    const emailResponse = await context.awaitResponse(
+      "Please provide your email address to receive the to-dos summary:",
+    );
+    email = emailResponse;
+
+    // Basic email validation
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(email)) {
+      await context.send(
+        "Invalid email format. Please try again with a valid email address.",
+      );
+      intents--;
+      continue;
+    }
+    break;
+  }
+  if (intents == 0) {
+    await context.send(
+      "I couldn't get your email address. Please try again later.",
+    );
+    return;
+  }
+  try {
+    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 Converse Summary</h3>
+        <p>${reply}</p>
+      `,
+      };
+      await resend.emails.send(content);
+      await context.send(`✅ Summary sent successfully to ${email}`);
+    } else {
+      await context.send("❌ Message not found.");
+    }
+  } catch (error) {
+    await context.send("❌ Failed to send email. Please try again later.");
+    console.error("Error sending email:", error);
+  }
+}

package/templates/playground/src/skills/token.ts

@@ -0,0 +1,57 @@
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+export const token: Skill[] = [
+  {
+    skill: "token",
+    handler: handler,
+    examples: ["/token bitcoin", "/token ethereum"],
+    description: "Get real time price of a any token.",
+    params: {
+      symbol: {
+        type: "string",
+      },
+    },
+  },
+];
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { symbol },
+      },
+    },
+  } = context;
+  const response = await fetch(
+    `https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&ids=${symbol}`,
+  );
+  if (!response.ok) {
+    context.send("Token not found");
+    context.send("try with its full name, instead of btc it would be bitcoin");
+    return;
+  }
+  const data = (await response.json()) as any;
+  const token = data[0];
+
+  const tokenInfo = {
+    name: token.name,
+    symbol: token.symbol.toUpperCase(),
+    price: token.current_price,
+    image: token.image,
+    link: `https://www.coingecko.com/en/coins/${token.id}`,
+  };
+
+  let frame = {
+    title: tokenInfo.name,
+    buttons: [
+      { content: "Buy", action: "link", target: tokenInfo.link },
+      {
+        content: `Price (${tokenInfo.price})`,
+        action: "link",
+        target: tokenInfo.link,
+      },
+    ],
+    image: tokenInfo.image,
+  };
+  await context.sendCustomFrame(frame);
+}