chore: minor adjustments and changes

Author: mrepol742

src/commands/build.ts

@@ -9,7 +9,7 @@ export const info = {
   description: "Build the bot (optionally clean before building).",
   usage: "build [--clean]",
   example: "build --clean",
-  role: "super-admin",
+  role: "admin",
   cooldown: 5000,
 };
 

src/commands/bylaws.ts

@@ -0,0 +1,51 @@
+import { Message } from "../types/message";
+import log from "../components/utils/log";
+
+export const info = {
+  command: "bylaws",
+  description: "Display the Bylaws of the bot.",
+  usage: "bylaws",
+  example: "bylaws",
+  role: "legal",
+  cooldown: 5000,
+};
+
+export default async function (msg: Message): Promise<void> {
+  const text = `
+  \`Bot Bylaws\`
+  These rules govern the use and responsibilities within this bot system.
+
+  ━━━━━━━━━━━━━━━━━━━━━━━
+  \`SuperAdmin (Bot Owner)\`
+  - Full control over all bot operations and data
+  - Can create, promote, or remove Admins and Legal roles
+  - Has access to all logs, configurations, and override powers
+  - Responsible for bot maintenance, updates, and critical decisions
+
+  \`Admin\`
+  - Moderate bot interactions and enforce rules
+  - Can mute, warn, or restrict users as necessary
+  - Assist in managing bot commands and features
+  - Cannot alter Legal or SuperAdmin permissions
+
+  \`Legal\`
+  - Oversees legal usage, terms of service, and compliance
+  - Handles copyright, data policy, and usage rights
+  - May update the bylaws with SuperAdmin approval
+  - Cannot manage users or bot configuration
+
+  \`User\`
+  - May use commands within defined limitations
+  - Must follow community guidelines and respect others
+  - Misuse or abuse can lead to restrictions
+  - Can report issues or violations to Admins or Legal
+
+  ━━━━━━━━━━━━━━━━━━━━━━━
+  All actions are logged and subject to review.
+  By using this bot, you agree to follow these bylaws.
+
+  Last updated: October 2025
+  `;
+
+  await msg.reply(text);
+}

src/commands/help.ts

@@ -5,124 +5,101 @@ import { commands } from "../components/utils/cmd/loader";
 export const info = {
   command: "help",
   description: "List available commands and their usage.",
-  usage: "help [page|role|command]",
-  example: "help admin",
+  usage: "help [--role] [page|command]",
+  example: "help --admin 2",
   role: "user",
   cooldown: 5000,
 };
 
 type CommandType = {
   command: string;
   role: string;
+  description?: string;
+  usage?: string;
+  example?: string;
+  cooldown?: number;
 };
 
 const PAGE_SIZE = 20;
+const validRoles = ["user", "admin", "super-admin", "legal"];
 
 function paginate(items: string[], page: number, pageSize: number): string[] {
   const start = (page - 1) * pageSize;
   return items.slice(start, start + pageSize);
 }
 
-function buildUserPage(
-  userCommands: string[],
+function buildRoleHelpPage(
+  commandsForRole: string[],
   page: number,
   totalPages: number,
+  role: string,
 ): string {
   let response = `
-    \`Help ${page}\`
-    help [command] for more details on a specific command.
+    \`Help ${role.charAt(0).toUpperCase() + role.slice(1)}\`
+    Use: *help [command]* for more details
 
-    |  •  ${userCommands.join("\n    |  •  ") || "_None_"}
+    |  •  ${commandsForRole.join("\n|  •  ") || "_None_"}
 
     \`Page ${page} of ${totalPages}\`
   `;
   return response;
 }
 
-function buildAdminPage(type: string, adminCommands: string[]): string {
-  let response = `
-    \`Help ${type}\`
-    help [command] for more details on a specific command.
-
-    |  •  ${adminCommands.join("\n    |  •  ") || "_None_"}
-  `;
-  return response;
-}
-
 export default async function (msg: Message): Promise<void> {
-  const match = /^help(?:\s+(admin|super-admin|\d+))?$/i.exec(msg.body.trim());
-  if (!match) return;
-
-  const query = msg.body
-    .replace(/^help\b\s*/i, "")
-    .trim()
-    .toLowerCase();
-
-  /*
-   * will show help for a specific command
-   */
-  const matchCommands = commands[query];
-  if (matchCommands) {
+  const query = msg.body.replace(/^help/i, "").trim();
+
+  // check if the query matches a specific command first
+  const possibleCommand = query.split(/\s+/)[0];
+  if (commands[possibleCommand]) {
+    const cmd = commands[possibleCommand] as CommandType;
     const response = `
-    \`${matchCommands.command}\`
-    ${matchCommands.description || "No description"}
+      \`${cmd.command}\`
+      ${cmd.description || "No description"}
 
-    *Usage:* ${matchCommands.usage || "No usage"}
-    *Example:* ${matchCommands.example || "No example"}
-    *Role:* ${matchCommands.role || "User"}
-    *Cooldown:* ${matchCommands.cooldown || 5000}ms
+      *Usage:* ${cmd.usage || "N/A"}
+      *Example:* ${cmd.example || "N/A"}
+      *Role:* ${cmd.role}
+      *Cooldown:* ${cmd.cooldown || 5000}ms
     `;
     await msg.reply(response);
     return;
   }
 
-  // help admin (group admins)
-  if (/^admin$/i.test(query)) {
-    const adminCommands = Object.values(commands)
-      .filter((cmd: CommandType) => cmd.role === "admin")
-      .map((cmd: CommandType) => cmd.command)
-      .sort((a, b) => a.localeCompare(b));
-    await msg.reply(buildAdminPage("Admin", adminCommands));
-    return;
-  }
-
-  // help super-admin (bot owner)
-  if (/^super-admin$/i.test(query)) {
-    const superCommands = Object.values(commands)
-      .filter((cmd: CommandType) => cmd.role === "super-admin")
-      .map((cmd: CommandType) => cmd.command)
-      .sort((a, b) => a.localeCompare(b));
-    await msg.reply(buildAdminPage("Super Admin", superCommands));
-    return;
-  }
-
-  if (!/^[1-9]\d*$/.test(query) && query != "") {
-    await msg.reply("Please type a valid page number.");
-    return;
+  // extract role and page
+  const args = query.split(/\s+/).filter(Boolean);
+  let role = "user";
+  let page = 1;
+
+  for (const arg of args) {
+    if (arg.startsWith("--")) {
+      const roleCandidate = arg.replace(/^--/, "").toLowerCase();
+      if (validRoles.includes(roleCandidate)) {
+        role = roleCandidate;
+      }
+    } else if (/^\d+$/.test(arg)) {
+      page = parseInt(arg, 10);
+    }
   }
 
-  // help [page]
-  const matchPage = query.match(/(\d+)?/i);
-  const page = Math.max(
-    1,
-    matchPage && matchPage[1] ? parseInt(matchPage[1], 10) : 1,
-  );
-
-  const userCommands = Object.values(commands)
-    .filter((cmd: CommandType) => cmd.role === "user")
+  const filteredCommands = Object.values(commands)
+    .filter((cmd: CommandType) => cmd.role === role)
     .map((cmd: CommandType) => cmd.command)
     .sort((a, b) => a.localeCompare(b));
 
-  userCommands.unshift("admin");
-  userCommands.unshift("super-admin");
-
-  if (Object.values(commands).length === 0) {
-    await msg.reply(`The *${page}* is obviously is not our bot bounds.`);
+  if (filteredCommands.length === 0) {
+    await msg.reply(`No commands found for role: *${role}*.`);
     return;
   }
 
-  const totalPages = Math.ceil(userCommands.length / PAGE_SIZE);
-  const userPage = paginate(userCommands, page, PAGE_SIZE);
+  const totalPages = Math.ceil(filteredCommands.length / PAGE_SIZE);
+  if (page < 1 || page > totalPages) {
+    await msg.reply(
+      `Page *${page}* is out of range. Total pages: *${totalPages}*.`,
+    );
+    return;
+  }
 
-  await msg.reply(buildUserPage(userPage, page, totalPages));
+  const paginated = paginate(filteredCommands, page, PAGE_SIZE);
+  const response = buildRoleHelpPage(paginated, page, totalPages, role);
+  await msg.reply(response);
 }

src/commands/legal.ts

@@ -9,7 +9,7 @@ export const info = {
   description: "Pull changes from the remote repository and show commit info.",
   usage: "update",
   example: "update",
-  role: "super-admin",
+  role: "admin",
   cooldown: 5000,
 };
 

src/commands/update.ts

@@ -211,11 +211,11 @@ export default async function (msg: Message, type: string): Promise<void> {
       return;
     }
 
-    if (
-      (rateLimitResult.status || rateLimitResult.value.timestamps.length > 5) &&
-      !isUserAdmin
-    ) {
-      await penalizeUser(lid, rateLimitResult.value);
+    if (rateLimitResult.status || rateLimitResult.value.timestamps.length > 5) {
+      await Promise.allSettled([
+        penalizeUser(lid, rateLimitResult.value),
+        msg.reply("You have been detected as spam, please wait for a while."),
+      ]);
       return;
     }
 
@@ -229,7 +229,6 @@ export default async function (msg: Message, type: string): Promise<void> {
       return;
     }
 
-
     log.info("Message", lid, key);
     msg.body = newMessageBody;
 
@@ -263,7 +262,7 @@ export default async function (msg: Message, type: string): Promise<void> {
       return await originalReply(messageBody, chatId, options);
     };
 
-    if (!msg.fromMe || !isUserAdmin) {
+    if (!msg.fromMe) {
       const isInapproiateResponse = checkInappropriate(msg.body);
       if (isInapproiateResponse.isInappropriate) {
         const text =