feat: bug fixes and improvements

- added pair, req & riddle commands
- added message content checker for offensive words
- update block command for reason
- update zsh command

Author: mrepol742

src/commands/block.ts

@@ -27,7 +27,11 @@ export default async function (msg: Message) {
     await prisma.block.upsert({
       where: { lid },
       update: {},
-      create: { lid, mode: msg.author ? "group" : "private" },
+      create: {
+        lid,
+        mode: msg.author ? "group" : "private",
+        reason: "Blocked by admin",
+      },
     });
   }
 

src/commands/chad.ts

@@ -1,4 +1,4 @@
-import { Message } from "../../types/message"
+import { Message } from "../../types/message";
 import log from "../components/utils/log";
 import agentHandler from "../components/ai/agentHandler";
 import { greetings } from "../components/utils/data";

src/commands/pair.ts

@@ -0,0 +1,60 @@
+import { Contact, GroupChat } from "whatsapp-web.js";
+import { Message } from "../../types/message";
+import client from "../components/client";
+
+export const info = {
+  command: "pair",
+  description: "Pair people and generate a love message",
+  usage: "pair",
+  example: "pair",
+  role: "user",
+  cooldown: 5000,
+};
+
+export default async function (msg: Message) {
+  if (!/^pair/i.test(msg.body)) return;
+
+  const chat = await msg.getChat();
+  if (!chat.isGroup) {
+    await msg.reply("This only works on group chats");
+    return;
+  }
+
+  const groupChat = chat as GroupChat;
+  const participants = groupChat.participants;
+
+  if (participants.length < 2) {
+    await msg.reply("Not enough people in the group to make a match 💔");
+    return;
+  }
+
+  const shuffled = participants.sort(() => 0.5 - Math.random());
+  const [p1, p2] = shuffled.slice(0, 2);
+
+  const whatsappClient = await client();
+  const [c1, c2]: [Contact, Contact] = await Promise.all([
+    whatsappClient.getContactById(p1.id._serialized),
+    whatsappClient.getContactById(p2.id._serialized),
+  ]);
+
+  const name1 = c1.pushname || c1.number;
+  const name2 = c2.pushname || c2.number;
+
+  const templates = [
+    `@${name1} and @${name2} are likely compatible! The love between @${name1} and @${name2} is unstoppable 💖`,
+    `Could @${name1} ❤️ fall for @${name2}? Absolutely, @${name2} will adore @${name1} forever 💘`,
+    `The stars shine for @${name2} and @${name1} 🌟 Their love is written in destiny 💫`,
+    `Everyone says @${name1} + @${name2} = pure magic ✨ Love is unstoppable!`,
+    `Rumor has it that @${name2} secretly loves @${name1} 😍 Compatibility level: 100%`,
+    `Watch out! @${name1} and @${name2}'s love story is about to go viral 💞`
+  ];
+
+  const message = templates[Math.floor(Math.random() * templates.length)];
+  await msg.reply(
+    message,
+    undefined,
+    {
+      mentions: [c1, c2] as any,
+    }
+  );
+}

src/commands/play.ts

@@ -118,10 +118,6 @@ export default async function play(msg: Message) {
     writeStream.on("error", reject);
   });
 
-  // simulates audio recording
-  const chat = await msg.getChat();
-  chat.sendStateRecording();
-
   await execPromise(`ffmpeg -y -i "${tempPath}" -vn -c:a copy "${savePath}"`);
   const media = MessageMedia.fromFilePath(savePath);
   Promise.all([msg.reply(media), fs.promises.unlink(tempPath)]);

src/commands/req.ts

@@ -0,0 +1,59 @@
+import { Message } from "../../types/message";
+import {
+  findOrCreateUser,
+  getUserbyLid,
+  isBlocked,
+} from "../components/services/user";
+import redis from "../components/redis";
+import { client } from "../components/client";
+import { MessageMedia } from "whatsapp-web.js";
+import { prisma } from "../components/prisma";
+import timestamp from "../components/utils/timestamp";
+
+export const info = {
+  command: "req",
+  description: "Register a user.",
+  usage: "req @user",
+  example: "req @user",
+  role: "admin",
+  cooldown: 5000,
+};
+
+export default async function (msg: Message) {
+  const chat = await msg.getChat();
+  if (!chat.isGroup) {
+    await msg.reply("This only works on group chats");
+    return;
+  }
+
+  if (msg.mentionedIds.length === 0) {
+    await msg.reply("Please mention a user to stalk.");
+    return;
+  }
+
+  const jid = msg.mentionedIds[0];
+  const lid = jid.split("@")[0];
+
+  const user = await prisma.user
+    .update({
+      where: { lid },
+      data: {},
+    })
+    .catch(() => null);
+
+  if (user) {
+    await msg.reply(
+      `\`${user.name}\` registered since ${timestamp(user.createdAt.getTime())}.`,
+    );
+    return;
+  }
+
+  msg.author = jid;
+  const register = await findOrCreateUser(msg);
+  if (register) {
+    await msg.reply("The user has been registered successfully.");
+    return;
+  }
+
+  await msg.reply("Failed! Please try again later.");
+}

src/commands/riddle.ts

@@ -0,0 +1,31 @@
+import { Message } from "../../types/message";
+import { riddles } from "../components/utils/data";
+import log from "../components/utils/log";
+import redis from "../components/redis";
+
+export const info = {
+  command: "riddle",
+  description: "Get a random riddle that will shake your head.",
+  usage: "riddle",
+  example: "riddle",
+  role: "user",
+  cooldown: 5000,
+};
+
+export default async function (msg: Message) {
+  if (!/^riddle/i.test(msg.body)) return;
+
+  const id = Math.floor(Math.random() * riddles.length);
+  const response = riddles[id];
+
+  let text = `
+    \`${response.question}\`
+  `;
+
+  const messageReturn = await msg.reply(text);
+  redis.set(
+    `riddle:${messageReturn.id.id}`,
+    JSON.stringify({ riddle_id: id.toString() }),
+  );
+  log.info("riddle", `Riddle sent: ${response.question}`);
+}

src/commands/say.ts

@@ -28,10 +28,6 @@ export default async function (msg: Message) {
     host: "https://translate.google.com",
   });
 
-  // simulates audio recording
-  const chat = await msg.getChat();
-  chat.sendStateRecording();
-
   const response = await axios.get(url, { responseType: "arraybuffer" });
   const buffer = Buffer.from(response.data);
   const tempDir = "./.temp";
@@ -48,7 +44,7 @@ export default async function (msg: Message) {
     audioBuffer.toString("base64"),
     `${filename}.mp3`,
   );
-  await msg.reply(media, msg.from, {
+  await msg.reply(media, undefined, {
     sendAudioAsVoice: true,
   });
   await fs.promises.unlink(tempPath);

src/commands/stalk.ts

@@ -14,6 +14,12 @@ export const info = {
 };
 
 export default async function (msg: Message) {
+  const chat = await msg.getChat();
+  if (!chat.isGroup) {
+    await msg.reply("This only works on group chats");
+    return;
+  }
+
   if (msg.mentionedIds.length === 0) {
     await msg.reply("Please mention a user to stalk.");
     return;

src/commands/zsh.ts

@@ -1,4 +1,4 @@
-import { Message } from "../../types/message"
+import { Message } from "../../types/message";
 import log from "../components/utils/log";
 import { exec } from "child_process";
 import util from "util";
@@ -23,18 +23,15 @@ export default async function (msg: Message) {
   const execPromise = util.promisify(exec);
 
   const { stdout, stderr } = await execPromise(query, {
-    timeout: 60000,
+    timeout: 30000,
     maxBuffer: 1024 * 1024,
     shell: process.env.SHELL || "/bin/zsh",
   });
-  let response = stdout || stderr || "No output.";
+  let response = `${stdout} \n\n ${stderr}`;
   if (response.length > 4000) {
     response = response.slice(0, 4000) + "\n\n[Output truncated]";
   }
 
-  await Promise.all([
-    msg.reply(response),
-    logService(msg, query, response),
-    log.warn("zsh", `Executed command: ${query}`),
-  ]);
+  await Promise.all([msg.reply(response), logService(msg, query, response)]);
+  log.warn("zsh", `Executed command: ${query}`);
 }

src/components/events/message.ts

@@ -20,6 +20,9 @@ import { phishingSet } from "../../index";
 import { getSetting } from "../services/settings";
 import { normalize } from "../utils/url";
 import { InstantDownloader } from "../utils/instantdl/downloader";
+import riddle from "../utils/riddle";
+import { checkInappropriate } from "../utils/contentChecker";
+import { prisma } from "../prisma";
 
 const regex = emojiRegex();
 const commandPrefix = process.env.COMMAND_PREFIX || "!";
@@ -114,7 +117,8 @@ export default async function (msg: Message, type: string) {
     Promise.resolve().then(async () => {
       const quoted = await msg.getQuotedMessage();
       if (!quoted.body || isRateLimit.status) return;
-      await quiz(msg, quoted);
+
+      await Promise.all([quiz(msg, quoted), riddle(msg, quoted)]);
     });
   }
 
@@ -226,14 +230,38 @@ export default async function (msg: Message, type: string) {
     options?: MessageSendOptions,
   ): Promise<Message> => {
     let messageBody = typeof content === "string" ? Font(content) : content;
-
     log.info("ReplyMessage", lid, content.toString().slice(0, 150));
 
     if (Math.random() < 0.5)
       return (await client()).sendMessage(msg.id.remote, messageBody, options);
     return await originalReply(messageBody, chatId, options);
   };
 
+  const isInapproiateResponse = checkInappropriate(msg.body);
+  if (isInapproiateResponse.isInappropriate) {
+    const text =
+      "You have been blocked. For more information \`terms\` & \`privacy\`.";
+    await Promise.all([
+      originalReply(text),
+      prisma.block.upsert({
+        where: { lid },
+        update: {},
+        create: {
+          lid,
+          mode: msg.author ? "group" : "private",
+          reason: `Inapproiate ${isInapproiateResponse.words.join(", ")}`,
+        },
+      }),
+      prisma.user.update({
+        where: { lid },
+        data: { points: { decrement: 100 } },
+      }),
+    ]);
+
+    log.info("BlockUser", lid);
+    return;
+  }
+
   if (
     /^(--?help|\bhelp\b|-h)$/i.test(
       msg.body.trim().replace(handler.command, "").trim(),
@@ -256,23 +284,7 @@ export default async function (msg: Message, type: string) {
    * Execute the command handler.
    */
   try {
-    await Promise.all([
-      (async () => {
-        if (msg.fromMe) return;
-
-        const chat = await msg.getChat();
-        chat.sendStateTyping();
-      })(),
-
-      handler.exec(msg),
-
-      (async () => {
-        if (!msg.author) return;
-
-        const user = await findOrCreateUser(msg);
-        if (user) await msg.react("✅");
-      })(),
-    ]);
+    await Promise.all([handler.exec(msg), findOrCreateUser(msg)]);
   } catch (error: any) {
     if (error.response) {
       const { status, headers } = error.response;