Reverting

.claude/settings.local.json

···
       "mcp__git-mcp-server__git_push",
       "Bash(bunx tsc:*)",
       "Bash(DID=did:test OZONE_URL=http://test OZONE_PDS=http://test BSKY_HANDLE=test.bsky.social BSKY_PASSWORD=testpass bun --eval \"import(''./src/validateEnv.js'').then(m => m.validateEnvironment())\")",
-      "mcp__git-mcp-server__git_add"
+      "mcp__git-mcp-server__git_add",
+      "Bash(bunx eslint:*)"
     ],
     "ask": [
       "curl"

src/agent.ts

···
-import { AtpAgent } from '@atproto/api';
-import { setGlobalDispatcher, Agent as Agent } from 'undici';
-
+import { setGlobalDispatcher, Agent as Agent } from "undici";
 setGlobalDispatcher(new Agent({ connect: { timeout: 20_000 } }));
-import { BSKY_HANDLE, BSKY_PASSWORD, OZONE_PDS } from './config.js';
+import { BSKY_HANDLE, BSKY_PASSWORD, OZONE_PDS } from "./config.js";
+import { AtpAgent } from "@atproto/api";
 
 export const agent = new AtpAgent({
   service: `https://${OZONE_PDS}`,

src/checkHandles.ts

···
-import { HANDLE_CHECKS } from './constants.js';
-import logger from './logger.js';
+import { HANDLE_CHECKS } from "./constants.js";
+import logger from "./logger.js";
 import {
   createAccountReport,
   createAccountComment,
   createAccountLabel,
-} from './moderation.js';
+} from "./moderation.js";
 
-export const checkHandle = (
+export const checkHandle = async (
   did: string,
   handle: string,
   time: number,
 ) => {
-  try {
-    // Get a list of labels
-    const labels: string[] = Array.from(
-      HANDLE_CHECKS,
-      (handleCheck) => handleCheck.label,
+  // Get a list of labels
+  const labels: string[] = Array.from(
+    HANDLE_CHECKS,
+    (handleCheck) => handleCheck.label,
+  );
+
+  // iterate through the labels
+  labels.forEach((label) => {
+    const checkList = HANDLE_CHECKS.find(
+      (handleCheck) => handleCheck.label === label,
     );
 
-    // iterate through the labels
-    labels.forEach((label) => {
-      const checkList = HANDLE_CHECKS.find(
-        (handleCheck) => handleCheck.label === label,
-      );
+    if (checkList?.ignoredDIDs) {
+      if (checkList.ignoredDIDs.includes(did)) {
+        logger.info(`Whitelisted DID: ${did}`);
+        return;
+      }
+    }
 
-      if (checkList?.ignoredDIDs) {
-        if (checkList.ignoredDIDs.includes(did)) {
-          logger.info(`Whitelisted DID: ${did}`);
+    if (checkList!.check.test(handle)) {
+      // False-positive checks
+      if (checkList?.whitelist) {
+        if (checkList?.whitelist.test(handle)) {
+          logger.info(`Whitelisted phrase found for: ${handle}`);
           return;
         }
       }
 
-      if (checkList?.check.test(handle)) {
-      // False-positive checks
-        if (checkList.whitelist) {
-          if (checkList.whitelist.test(handle)) {
-            logger.info(`Whitelisted phrase found for: ${handle}`);
-            return;
-          }
+      if (checkList?.toLabel === true) {
+        logger.info(`[CHECKHANDLE]: Labeling ${did} for ${checkList!.label}`);
+        {
+          createAccountLabel(
+            did,
+            `${checkList!.label}`,
+            `${time}: ${checkList!.comment} - ${handle}`,
+          );
         }
+      }
 
-        if (checkList.toLabel) {
-          logger.info(`[CHECKHANDLE]: Labeling ${did} for ${checkList.label}`);
-          {
-            void createAccountLabel(
-              did,
-              checkList.label,
-              `${time.toString()}: ${checkList.comment} - ${handle}`,
-            );
-          }
-        }
+      if (checkList?.reportAcct === true) {
+        logger.info(`[CHECKHANDLE]: Reporting ${did} for ${checkList!.label}`);
+        createAccountReport(did, `${time}: ${checkList!.comment} - ${handle}`);
+      }
 
-        if (checkList.reportAcct) {
-          logger.info(`[CHECKHANDLE]: Reporting ${did} for ${checkList.label}`);
-          void createAccountReport(did, `${time.toString()}: ${checkList.comment} - ${handle}`);
-        }
-
-        if (checkList.commentAcct) {
-          logger.info(
-            `[CHECKHANDLE]: Commenting on ${did} for ${checkList.label}`,
-          );
-          void createAccountComment(did, `${time.toString()}: ${checkList.comment} - ${handle}`);
-        }
+      if (checkList?.commentAcct === true) {
+        logger.info(
+          `[CHECKHANDLE]: Commenting on ${did} for ${checkList!.label}`,
+        );
+        createAccountComment(did, `${time}: ${checkList!.comment} - ${handle}`);
       }
-    });
-  } catch (error) {
-    logger.error(`Error in checkHandle for ${did}:`, error);
-    throw error;
-  }
+    }
+  });
 };

src/checkPosts.ts

···
-import { LINK_SHORTENER, POST_CHECKS } from './constants.js';
-import logger from './logger.js';
+import { LINK_SHORTENER, POST_CHECKS, langs } from "./constants.js";
+import logger from "./logger.js";
 import {
   createPostLabel,
   createAccountReport,
   createAccountComment,
   createPostReport,
-} from './moderation.js';
-import type { Post } from './types.js';
-import { getFinalUrl, getLanguage } from './utils.js';
+} from "./moderation.js";
+import type { Post } from "./types.js";
+import { getFinalUrl, getLanguage } from "./utils.js";
 
 export const checkPosts = async (post: Post[]) => {
-  try {
-    // Get a list of labels
-    const labels: string[] = Array.from(
-      POST_CHECKS,
-      (postCheck) => postCheck.label,
-    );
+  // Get a list of labels
+  const labels: string[] = Array.from(
+    POST_CHECKS,
+    (postCheck) => postCheck.label,
+  );
 
-    const urlRegex = /https?:\/\/[^\s]+/g;
+  const urlRegex = /https?:\/\/[^\s]+/g;
 
-    // Check for link shorteners
-    if (LINK_SHORTENER.test(post[0].text)) {
-      try {
-        const url = post[0].text.match(urlRegex);
-        if (url && LINK_SHORTENER.test(url[0])) {
-          logger.info(`[CHECKPOSTS]: Checking shortened URL: ${url[0]}`);
-          const finalUrl = await getFinalUrl(url[0]);
-          if (finalUrl) {
-            const originalUrl = post[0].text;
-            post[0].text = post[0].text.replace(url[0], finalUrl);
-            logger.info(
-              `[CHECKPOSTS]: Shortened URL resolved: ${originalUrl} -> ${finalUrl}`,
-            );
-          }
+  // Check for link shorteners
+  if (LINK_SHORTENER.test(post[0].text)) {
+    try {
+      const url = post[0].text.match(urlRegex);
+      if (url && LINK_SHORTENER.test(url[0])) {
+        logger.info(`[CHECKPOSTS]: Checking shortened URL: ${url[0]}`);
+        const finalUrl = await getFinalUrl(url[0]);
+        if (finalUrl) {
+          const originalUrl = post[0].text;
+          post[0].text = post[0].text.replace(url[0], finalUrl);
+          logger.info(
+            `[CHECKPOSTS]: Shortened URL resolved: ${originalUrl} -> ${finalUrl}`,
+          );
         }
-      } catch (error) {
-        logger.error(
-          `[CHECKPOSTS]: Failed to resolve shortened URL: ${post[0].text}`,
-          error,
-        );
-      // Keep the original URL if resolution fails
       }
+    } catch (error) {
+      logger.error(
+        `[CHECKPOSTS]: Failed to resolve shortened URL: ${post[0].text}`,
+        error,
+      );
+      // Keep the original URL if resolution fails
     }
+  }
 
-    // Get the post's language
-    const lang = await getLanguage(post[0].text);
+  // Get the post's language
+  const lang = await getLanguage(post[0].text);
 
-    // iterate through the labels
-    labels.forEach((label) => {
-      const checkPost = POST_CHECKS.find(
-        (postCheck) => postCheck.label === label,
-      );
+  // iterate through the labels
+  labels.forEach((label) => {
+    const checkPost = POST_CHECKS.find(
+      (postCheck) => postCheck.label === label,
+    );
 
-      if (checkPost?.language || checkPost?.language !== undefined) {
-        if (!checkPost.language.includes(lang)) {
-          return;
-        }
+    if (checkPost?.language || checkPost?.language !== undefined) {
+      if (!checkPost?.language.includes(lang)) {
+        return;
       }
+    }
 
-      if (checkPost?.ignoredDIDs) {
-        if (checkPost.ignoredDIDs.includes(post[0].did)) {
-          logger.info(`[CHECKPOSTS]: Whitelisted DID: ${post[0].did}`);
-          return;
-        }
+    if (checkPost?.ignoredDIDs) {
+      if (checkPost?.ignoredDIDs.includes(post[0].did)) {
+        logger.info(`[CHECKPOSTS]: Whitelisted DID: ${post[0].did}`);
+        return;
       }
+    }
 
-      if (checkPost?.check.test(post[0].text)) {
+    if (checkPost!.check.test(post[0].text)) {
       // Check if post is whitelisted
-        if (checkPost.whitelist) {
-          if (checkPost.whitelist.test(post[0].text)) {
-            logger.info('[CHECKPOSTS]: Whitelisted phrase found"');
-            return;
-          }
+      if (checkPost?.whitelist) {
+        if (checkPost?.whitelist.test(post[0].text)) {
+          logger.info(`[CHECKPOSTS]: Whitelisted phrase found"`);
+          return;
         }
+      }
 
-        if (checkPost.toLabel) {
-          logger.info(
-            `[CHECKPOSTS]: Labeling ${post[0].atURI} for ${checkPost.label}`,
-          );
-          void createPostLabel(
-            post[0].atURI,
-            post[0].cid,
-            checkPost.label,
-            `${post[0].time.toString()}: ${checkPost.comment} at ${post[0].atURI} with text "${post[0].text}"`,
-          );
-        }
+      if (checkPost!.toLabel === true) {
+        logger.info(
+          `[CHECKPOSTS]: Labeling ${post[0].atURI} for ${checkPost!.label}`,
+        );
+        createPostLabel(
+          post[0].atURI,
+          post[0].cid,
+          `${checkPost!.label}`,
+          `${post[0].time}: ${checkPost!.comment} at ${post[0].atURI} with text "${post[0].text}"`,
+        );
+      }
 
-        if (checkPost.reportPost) {
-          logger.info(
-            `[CHECKPOSTS]: Reporting ${post[0].atURI} for ${checkPost.label}`,
-          );
-          logger.info(`Reporting: ${post[0].atURI}`);
-          void createPostReport(
-            post[0].atURI,
-            post[0].cid,
-            `${post[0].time.toString()}: ${checkPost.comment} at ${post[0].atURI} with text "${post[0].text}"`,
-          );
-        }
+      if (checkPost!.reportPost === true) {
+        logger.info(
+          `[CHECKPOSTS]: Reporting ${post[0].atURI} for ${checkPost!.label}`,
+        );
+        logger.info(`Reporting: ${post[0].atURI}`);
+        createPostReport(
+          post[0].atURI,
+          post[0].cid,
+          `${post[0].time}: ${checkPost!.comment} at ${post[0].atURI} with text "${post[0].text}"`,
+        );
+      }
 
-        if (checkPost.reportAcct) {
-          logger.info(
-            `[CHECKPOSTS]: Reporting on ${post[0].did} for ${checkPost.label} in ${post[0].atURI}`,
-          );
-          void createAccountReport(
-            post[0].did,
-            `${post[0].time.toString()}: ${checkPost.comment} at ${post[0].atURI} with text "${post[0].text}"`,
-          );
-        }
+      if (checkPost!.reportAcct === true) {
+        logger.info(
+          `[CHECKPOSTS]: Reporting on ${post[0].did} for ${checkPost!.label} in ${post[0].atURI}`,
+        );
+        createAccountReport(
+          post[0].did,
+          `${post[0].time}: ${checkPost?.comment} at ${post[0].atURI} with text "${post[0].text}"`,
+        );
+      }
 
-        if (checkPost.commentAcct) {
-          logger.info(
-            `[CHECKPOSTS]: Commenting on ${post[0].did} for ${checkPost.label} in ${post[0].atURI}`,
-          );
-          void createAccountComment(
-            post[0].did,
-            `${post[0].time.toString()}: ${checkPost.comment} at ${post[0].atURI} with text "${post[0].text}"`,
-          );
-        }
+      if (checkPost!.commentAcct === true) {
+        logger.info(
+          `[CHECKPOSTS]: Commenting on ${post[0].did} for ${checkPost!.label} in ${post[0].atURI}`,
+        );
+        createAccountComment(
+          post[0].did,
+          `${post[0].time}: ${checkPost?.comment} at ${post[0].atURI} with text "${post[0].text}"`,
+        );
       }
-    });
-  } catch (error) {
-    logger.error(`Error in checkPosts for ${post[0]?.did}:`, error);
-    throw error;
-  }
+    }
+  });
 };

src/checkProfiles.ts

···
-import { PROFILE_CHECKS } from './constants.js';
-import logger from './logger.js';
+import { PROFILE_CHECKS } from "./constants.js";
+import logger from "./logger.js";
 import {
   createAccountReport,
   createAccountLabel,
   createAccountComment,
-} from './moderation.js';
-import { getLanguage } from './utils.js';
+} from "./moderation.js";
+import { getLanguage } from "./utils.js";
 
 export const checkDescription = async (
   did: string,
···
       if (description) {
         if (checkProfiles?.description === true) {
           if (checkProfiles.check.test(description)) {
-          // Check if description is whitelisted
+            // Check if description is whitelisted
             if (checkProfiles.whitelist) {
               if (checkProfiles.whitelist.test(description)) {
-                logger.info('[CHECKDESCRIPTION]: Whitelisted phrase found.');
+                logger.info("[CHECKDESCRIPTION]: Whitelisted phrase found.");
                 return;
               }
             }
···
       if (displayName) {
         if (checkProfiles?.displayName === true) {
           if (checkProfiles.check.test(displayName)) {
-          // Check if displayName is whitelisted
+            // Check if displayName is whitelisted
             if (checkProfiles.whitelist) {
               if (checkProfiles.whitelist.test(displayName)) {
-                logger.info('[CHECKDISPLAYNAME]: Whitelisted phrase found.');
+                logger.info("[CHECKDISPLAYNAME]: Whitelisted phrase found.");
                 return;
               }
             }

src/checkStarterPack.ts

···
-import { PROFILE_CHECKS, STARTERPACK_CHECKS } from './constants.js';
-import logger from './logger.js';
+import { PROFILE_CHECKS, STARTERPACK_CHECKS } from "./constants.js";
+import logger from "./logger.js";
 import {
   createAccountLabel,
   createAccountReport,
   createPostLabel,
-} from './moderation.js';
+} from "./moderation.js";
 
-export const checkStarterPack = (
+export const checkStarterPack = async (
   did: string,
   time: number,
   atURI: string,
 ) => {
-  try {
-    // Get a list of labels
-    const labels: string[] = Array.from(
-      PROFILE_CHECKS,
-      (profileCheck) => profileCheck.label,
+  // Get a list of labels
+  const labels: string[] = Array.from(
+    PROFILE_CHECKS,
+    (profileCheck) => profileCheck.label,
+  );
+
+  // iterate through the labels
+  labels.forEach((label) => {
+    const checkProfiles = PROFILE_CHECKS.find(
+      (profileCheck) => profileCheck.label === label,
     );
 
-    // iterate through the labels
-    labels.forEach((label) => {
-      const checkProfiles = PROFILE_CHECKS.find(
-        (profileCheck) => profileCheck.label === label,
-      );
-
-      // Check if DID is whitelisted
-      if (checkProfiles?.ignoredDIDs) {
-        if (checkProfiles.ignoredDIDs.includes(did)) {
-          logger.info(`Whitelisted DID: ${did}`); return;
-        }
+    // Check if DID is whitelisted
+    if (checkProfiles?.ignoredDIDs) {
+      if (checkProfiles.ignoredDIDs.includes(did)) {
+        return logger.info(`Whitelisted DID: ${did}`);
       }
+    }
 
-      if (atURI) {
-        if (checkProfiles?.starterPacks) {
-          if (checkProfiles.starterPacks.includes(atURI)) {
-            logger.info(`Account joined via starter pack at: ${atURI}`);
-            void createAccountLabel(
-              did,
-              checkProfiles.label,
-              `${time.toString()}: ${checkProfiles.comment} - Account joined via starter pack at: ${atURI}`,
-            );
-          }
+    if (atURI) {
+      if (checkProfiles?.starterPacks) {
+        if (checkProfiles?.starterPacks.includes(atURI)) {
+          logger.info(`Account joined via starter pack at: ${atURI}`);
+          createAccountLabel(
+            did,
+            `${checkProfiles!.label}`,
+            `${time}: ${checkProfiles!.comment} - Account joined via starter pack at: ${atURI}`,
+          );
         }
       }
-    });
-  } catch (error) {
-    logger.error(`Error in checkStarterPack for ${did}:`, error);
-    throw error;
-  }
+    }
+  });
 };
 
-export const checkNewStarterPack = (
+export const checkNewStarterPack = async (
   did: string,
   time: number,
   atURI: string,
···
   packName: string | undefined,
   description: string | undefined,
 ) => {
-  try {
-    const labels: string[] = STARTERPACK_CHECKS.map((SPCheck) => SPCheck.label);
+  const labels: string[] = Array.from(
+    STARTERPACK_CHECKS,
+    (SPCheck) => SPCheck.label,
+  );
+
+  labels.forEach((label) => {
+    const checkList = PROFILE_CHECKS.find((SPCheck) => SPCheck.label === label);
 
-    labels.forEach((label) => {
-      const checkList = STARTERPACK_CHECKS.find((SPCheck) => SPCheck.label === label);
+    if (checkList?.knownVectors?.includes(did)) {
+      createPostLabel(
+        atURI,
+        cid,
+        `${checkList!.label}`,
+        `${time}: Starter pack created by known vector for ${checkList!.label} at: ${atURI}"`,
+      );
+      createAccountReport(
+        did,
+        `${time}: Starter pack created by known vector for ${checkList!.label} at: ${atURI}"`,
+      );
+    }
 
-      if (checkList?.knownVectors?.includes(did)) {
-        void createPostLabel(
+    if (description) {
+      if (checkList!.check.test(description)) {
+        logger.info(`Labeling post: ${atURI}`);
+        createPostLabel(
           atURI,
           cid,
-          checkList.label,
-          `${time.toString()}: Starter pack created by known vector for ${checkList.label} at: ${atURI}"`,
+          `${checkList!.label}`,
+          `${time}: ${checkList!.comment} at ${atURI} with text "${description}"`,
         );
-        void createAccountReport(
+        createAccountReport(
           did,
-          `${time.toString()}: Starter pack created by known vector for ${checkList.label} at: ${atURI}"`,
+          `${time}: ${checkList!.comment} at ${atURI} with text "${description}"`,
         );
       }
+    }
 
-      if (description) {
-        if (checkList?.check.test(description)) {
-          logger.info(`Labeling post: ${atURI}`);
-          void createPostLabel(
-            atURI,
-            cid,
-            checkList.label,
-            `${time.toString()}: ${checkList.comment} at ${atURI} with text "${description}"`,
-          );
-          void createAccountReport(
-            did,
-            `${time.toString()}: ${checkList.comment} at ${atURI} with text "${description}"`,
-          );
-        }
-      }
-
-      if (packName) {
-        if (checkList?.check.test(packName)) {
-          logger.info(`Labeling post: ${atURI}`);
-          void createPostLabel(
-            atURI,
-            cid,
-            checkList.label,
-            `${time.toString()}: ${checkList.comment} at ${atURI} with pack name "${packName}"`,
-          );
-          void createAccountReport(
-            did,
-            `${time.toString()}: ${checkList.comment} at ${atURI} with pack name "${packName}"`,
-          );
-        }
+    if (packName) {
+      if (checkList!.check.test(packName)) {
+        logger.info(`Labeling post: ${atURI}`);
+        createPostLabel(
+          atURI,
+          cid,
+          `${checkList!.label}`,
+          `${time}: ${checkList!.comment} at ${atURI} with pack name "${packName}"`,
+        );
+        createAccountReport(
+          did,
+          `${time}: ${checkList!.comment} at ${atURI} with pack name "${packName}"`,
+        );
       }
-    });
-  } catch (error) {
-    logger.error(`Error in checkNewStarterPack for ${did}:`, error);
-    throw error;
-  }
+    }
+  });
 };

src/config.ts

···
-import 'dotenv/config';
+import "dotenv/config";
 
-export const MOD_DID = process.env.DID ?? '';
-export const OZONE_URL = process.env.OZONE_URL ?? '';
-export const OZONE_PDS = process.env.OZONE_PDS ?? '';
-export const BSKY_HANDLE = process.env.BSKY_HANDLE ?? '';
-export const BSKY_PASSWORD = process.env.BSKY_PASSWORD ?? '';
-export const HOST = process.env.HOST ?? '127.0.0.1';
+export const MOD_DID = process.env.DID ?? "";
+export const OZONE_URL = process.env.OZONE_URL ?? "";
+export const OZONE_PDS = process.env.OZONE_PDS ?? "";
+export const BSKY_HANDLE = process.env.BSKY_HANDLE ?? "";
+export const BSKY_PASSWORD = process.env.BSKY_PASSWORD ?? "";
+export const HOST = process.env.HOST ?? "127.0.0.1";
 export const PORT = process.env.PORT ? Number(process.env.PORT) : 4100;
 export const METRICS_PORT = process.env.METRICS_PORT
   ? Number(process.env.METRICS_PORT)
   : 4101; // Left this intact from the code I adapted this from
 export const FIREHOSE_URL =
-  process.env.FIREHOSE_URL ?? 'wss://jetstream1.us-east.bsky.network/subscribe';
+  process.env.FIREHOSE_URL ?? "wss://jetstream.atproto.tools/subscribe";
 export const WANTED_COLLECTION = [
-  'app.bsky.feed.post',
-  'app.bsky.actor.defs',
-  'app.bsky.actor.profile',
+  "app.bsky.feed.post",
+  "app.bsky.actor.defs",
+  "app.bsky.actor.profile",
 ];
 export const CURSOR_UPDATE_INTERVAL = process.env.CURSOR_UPDATE_INTERVAL
   ? Number(process.env.CURSOR_UPDATE_INTERVAL)
   : 60000;
-export const { LABEL_LIMIT } = process.env;
-export const { LABEL_LIMIT_WAIT } = process.env;
+export const LABEL_LIMIT = process.env.LABEL_LIMIT;
+export const LABEL_LIMIT_WAIT = process.env.LABEL_LIMIT_WAIT;

src/homoglyphs.ts

···
+/* eslint-disable no-misleading-character-class */
+
+export const homoglyphMap: Record<string, string> = {
+  // Confusables for 'a'
+  á: "a",
+  à: "a",
+  ă: "a",
+  ắ: "a",
+  ằ: "a",
+  ẵ: "a",
+  ẳ: "a",
+  â: "a",
+  ấ: "a",
+  ầ: "a",
+  ẫ: "a",
+  ẩ: "a",
+  ǎ: "a",
+  å: "a",
+  ǻ: "a",
+  ä: "a",
+  ǟ: "a",
+  ã: "a",
+  ȧ: "a",
+  ǡ: "a",
+  ą: "a",
+  ą́: "a",
+  ą̃: "a",
+  ā: "a",
+  ā̀: "a",
+  ả: "a",
+  ȁ: "a",
+  a̋: "a",
+  ȃ: "a",
+  ạ: "a",
+  ặ: "a",
+  ậ: "a",
+  ḁ: "a",
+  ⱥ: "a",
+  "ꞻ": "a",
+  ᶏ: "a",
+  ẚ: "a",
+  ａ: "a",
+  "@": "a",
+  "4": "a",
+
+  // Confusables for 'e'
+  "3": "e",
+  є: "e",
+  е: "e",
+  é: "e",
+  è: "e",
+  ĕ: "e",
+  ê: "e",
+  ế: "e",
+  ề: "e",
+  ễ: "e",
+  ể: "e",
+  ê̄: "e",
+  ê̌: "e",
+  ě: "e",
+  ë: "e",
+  ẽ: "e",
+  ė: "e",
+  ė́: "e",
+  ė̃: "e",
+  ȩ: "e",
+  ḝ: "e",
+  ę: "e",
+  ę́: "e",
+  ę̃: "e",
+  ē: "e",
+  ḗ: "e",
+  ḕ: "e",
+  ẻ: "e",
+  ȅ: "e",
+  e̋: "e",
+  ȇ: "e",
+  ẹ: "e",
+  ệ: "e",
+  ḙ: "e",
+  ḛ: "e",
+  ɇ: "e",
+  e̩: "e",
+  è̩: "e",
+  é̩: "e",
+  ᶒ: "e",
+  ⱸ: "e",
+  ꬴ: "e",
+  ꬳ: "e",
+  ｅ: "e",
+
+  // Confusables for 'g'
+  ǵ: "g",
+  ğ: "g",
+  ĝ: "g",
+  ǧ: "g",
+  ġ: "g",
+  g̃: "g",
+  ģ: "g",
+  ḡ: "g",
+  ǥ: "g",
+  ꞡ: "g",
+  ɠ: "g",
+  ᶃ: "g",
+  ꬶ: "g",
+  ｇ: "g",
+  q: "g",
+  ꝗ: "g",
+  ꝙ: "g",
+  ɋ: "g",
+  ʠ: "g",
+
+  // Confusables for 'i' and 'l'
+  í: "i",
+  i̇́: "i",
+  ì: "i",
+  i̇̀: "i",
+  ĭ: "i",
+  î: "i",
+  ǐ: "i",
+  ï: "i",
+  ḯ: "i",
+  ĩ: "i",
+  i̇̃: "i",
+  į: "i",
+  į̇́: "i",
+  į̇̃: "i",
+  ī: "i",
+  ī̀: "i",
+  ỉ: "i",
+  ȉ: "i",
+  i̋: "i",
+  ȋ: "i",
+  ị: "i",
+  "ꞽ": "i",
+  ḭ: "i",
+  ɨ: "i",
+  ᶖ: "i",
+  ı: "i",
+  ｉ: "i",
+  "1": "i",
+  ĺ: "l",
+  ľ: "l",
+  ļ: "l",
+  ḷ: "l",
+  ḹ: "l",
+  l̃: "l",
+  ḽ: "l",
+  ḻ: "l",
+  ł: "l",
+  ŀ: "l",
+  ƚ: "l",
+  ꝉ: "l",
+  ⱡ: "l",
+  ɫ: "l",
+  ɬ: "l",
+  ꞎ: "l",
+  ꬷ: "l",
+  ꬸ: "l",
+  ꬹ: "l",
+  ᶅ: "l",
+  ɭ: "l",
+  ȴ: "l",
+  ｌ: "l",
+
+  // Confusables for 'k'
+  ḱ: "k",
+  ǩ: "k",
+  ķ: "k",
+  ḳ: "k",
+  ḵ: "k",
+  ƙ: "k",
+  ⱪ: "k",
+  ᶄ: "k",
+  ꝁ: "k",
+  ꝃ: "k",
+  ꝅ: "k",
+  ꞣ: "k",
+
+  // Confusables for 'n'
+  ń: "n",
+  ň: "n",
+  ñ: "n",
+  ṅ: "n",
+  ņ: "n",
+  ṇ: "n",
+  ṋ: "n",
+  ǹ: "n",
+  Ƞ: "n",
+  ƞ: "n",
+  ᵰ: "n",
+  ᶇ: "n",
+  ɳ: "n",
+  ȵ: "n",
+  ⁿ: "n",
+  ｎ: "n",
+  מ: "n",
+  и: "n",
+  п: "n",
+  ꬻ: "n",
+  ꬼ: "n",
+  n̈: "n",
+  ɲ: "n",
+  ŋ: "n",
+  ꞑ: "n",
+  ꞥ: "n",
+
+  // Confusables for 'o'
+  ó: "o",
+  ò: "o",
+  ŏ: "o",
+  ô: "o",
+  ố: "o",
+  ồ: "o",
+  ỗ: "o",
+  ổ: "o",
+  ǒ: "o",
+  ö: "o",
+  ȫ: "o",
+  ő: "o",
+  õ: "o",
+  ṍ: "o",
+  ṏ: "o",
+  ȭ: "o",
+  ȯ: "o",
+  o͘: "o",
+  ȱ: "o",
+  ø: "o",
+  ǿ: "o",
+  ǫ: "o",
+  ǭ: "o",
+  ō: "o",
+  ṓ: "o",
+  ṑ: "o",
+  ỏ: "o",
+  ȍ: "o",
+  ȏ: "o",
+  ơ: "o",
+  ớ: "o",
+  ờ: "o",
+  ỡ: "o",
+  ở: "o",
+  ợ: "o",
+  ọ: "o",
+  ộ: "o",
+  o̩: "o",
+  ò̩: "o",
+  ó̩: "o",
+  ɵ: "o",
+  ꝋ: "o",
+  ꝍ: "o",
+  ⱺ: "o",
+  ｏ: "o",
+  "0": "o",
+
+  // Confusables for 'r'
+  ŕ: "r",
+  ř: "r",
+  ṙ: "r",
+  ŗ: "r",
+  ȑ: "r",
+  ȓ: "r",
+  ṛ: "r",
+  ṝ: "r",
+  ṟ: "r",
+  r̃: "r",
+  ɍ: "r",
+  ꞧ: "r",
+  ɽ: "r",
+  ᵲ: "r",
+  ᶉ: "r",
+  ꭉ: "r",
+
+  // Confusables for 's'
+  ś: "s",
+  ṥ: "s",
+  ŝ: "s",
+  š: "s",
+  ṧ: "s",
+  ṡ: "s",
+  ş: "s",
+  ṣ: "s",
+  ṩ: "s",
+  ș: "s",
+  s̩: "s",
+  ꞩ: "s",
+  ȿ: "s",
+  ʂ: "s",
+  ᶊ: "s",
+  ᵴ: "s",
+
+  // Confusables for 't'
+  ť: "t",
+  ṫ: "t",
+  ţ: "t",
+  ṭ: "t",
+  ț: "t",
+  ṱ: "t",
+  ṯ: "t",
+  ŧ: "t",
+  ⱦ: "t",
+  ƭ: "t",
+  ʈ: "t",
+  ẗ: "t",
+  ᵵ: "t",
+  ƫ: "t",
+  ȶ: "t",
+};

src/limits.ts

···
-import { pRateLimit } from 'p-ratelimit'; // TypeScript
+import { pRateLimit } from "p-ratelimit"; // TypeScript
 
 // create a rate limiter that allows up to 30 API calls per second,
 // with max concurrency of 10

src/lists.ts

···
-import type { List } from './types.js';
+import { List } from "./types.js";
 
 export const LISTS: List[] = [
   {
-    label: 'blue-heart-emoji',
-    rkey: '3lfbtgosyyi22',
+    label: "blue-heart-emoji",
+    rkey: "3lfbtgosyyi22",
   },
   {
-    label: 'troll',
-    rkey: '3lbckxhgu3r2v',
+    label: "troll",
+    rkey: "3lbckxhgu3r2v",
   },
   {
-    label: 'maga-trump',
-    rkey: '3l53cjwlt4o2s',
+    label: "maga-trump",
+    rkey: "3l53cjwlt4o2s",
   },
   {
-    label: 'elon-musk',
-    rkey: '3l72tte74wa2m',
+    label: "elon-musk",
+    rkey: "3l72tte74wa2m",
   },
   {
-    label: 'rmve-imve',
-    rkey: '3l6tfurf7li27',
+    label: "rmve-imve",
+    rkey: "3l6tfurf7li27",
   },
   {
-    label: 'nazi-symbolism',
-    rkey: '3l6vdudxgeb2z',
+    label: "nazi-symbolism",
+    rkey: "3l6vdudxgeb2z",
   },
   {
-    label: 'hammer-sickle',
-    rkey: '3l4ue6w2aur2v',
+    label: "hammer-sickle",
+    rkey: "3l4ue6w2aur2v",
   },
   {
-    label: 'inverted-red-triangle',
-    rkey: '3l4ueabtpec2a',
+    label: "inverted-red-triangle",
+    rkey: "3l4ueabtpec2a",
   },
   {
-    label: 'automated-reply-guy',
-    rkey: '3lch7qbvzpx23',
+    label: "automated-reply-guy",
+    rkey: "3lch7qbvzpx23",
   },
   {
-    label: 'terf-gc',
-    rkey: '3lcqjqjdejs2x',
+    label: "terf-gc",
+    rkey: "3lcqjqjdejs2x",
   },
 ];

src/logger.ts

···
-import { pino } from 'pino';
+import { pino } from "pino";
 
 const logger = pino({
-  level: process.env.LOG_LEVEL ?? 'info',
+  level: process.env.LOG_LEVEL ?? "info",
   transport:
-    process.env.NODE_ENV !== 'production'
+    process.env.NODE_ENV !== "production"
       ? {
-        target: 'pino-pretty',
-        options: {
-          colorize: true,
-          translateTime: 'SYS:standard',
-          ignore: 'pid,hostname',
-        },
-      }
+          target: "pino-pretty",
+          options: {
+            colorize: true,
+            translateTime: "SYS:standard",
+            ignore: "pid,hostname",
+          },
+        }
       : undefined,
   timestamp: pino.stdTimeFunctions.isoTime,
 });

src/main.ts

···
   METRICS_PORT,
   WANTED_COLLECTION,
 } from "./config.js";
-import { validateEnvironment } from "./validateEnv.js";
 import logger from "./logger.js";
 import { startMetricsServer } from "./metrics.js";
+import { validateEnvironment } from "./validateEnv.js";
 import type { Post, LinkFeature } from "./types.js";
 
 validateEnvironment();

src/metrics.ts

···
-import express from 'express';
-import { Registry, collectDefaultMetrics } from 'prom-client';
+import express from "express";
+import { Registry, collectDefaultMetrics } from "prom-client";
 
-import logger from './logger.js';
+import logger from "./logger.js";
 
 const register = new Registry();
 collectDefaultMetrics({ register });
 
 const app = express();
 
-app.get('/metrics', (req, res) => {
+app.get("/metrics", (req, res) => {
   register
     .metrics()
     .then((metrics) => {
-      res.set('Content-Type', register.contentType);
+      res.set("Content-Type", register.contentType);
       res.send(metrics);
     })
     .catch((ex: unknown) => {
···
     });
 });
 
-export const startMetricsServer = (port: number, host = '127.0.0.1') => {
+export const startMetricsServer = (port: number, host = "127.0.0.1") => {
   return app.listen(port, host, () => {
     logger.info(`Metrics server is listening on ${host}:${port}`);
   });

src/moderation.ts

···
-import { agent, isLoggedIn } from './agent.js';
-import { MOD_DID } from './config.js';
-import { limit } from './limits.js';
-import { LISTS } from './lists.js';
-import logger from './logger.js';
+import { agent, isLoggedIn } from "./agent.js";
+import { MOD_DID } from "./config.js";
+import { limit } from "./limits.js";
+import { LISTS } from "./lists.js";
+import logger from "./logger.js";
 
 export const createPostLabel = async (
   uri: string,
···
       return await agent.tools.ozone.moderation.emitEvent(
         {
           event: {
-            $type: 'tools.ozone.moderation.defs#modEventLabel',
+            $type: "tools.ozone.moderation.defs#modEventLabel",
             comment,
             createLabelVals: [label],
             negateLabelVals: [],
           },
           // specify the labeled post by strongRef
           subject: {
-            $type: 'com.atproto.repo.strongRef',
+            $type: "com.atproto.repo.strongRef",
             uri,
             cid,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? '',
+          createdBy: agent.did ?? "",
           createdAt: new Date().toISOString(),
         },
         {
-          encoding: 'application/json',
+          encoding: "application/json",
           headers: {
-            'atproto-proxy': `${MOD_DID}#atproto_labeler`,
-            'atproto-accept-labelers':
-              'did:plc:ar7c4by46qjdydhdevvrndac;redact',
+            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-accept-labelers":
+              "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
···
       await agent.tools.ozone.moderation.emitEvent(
         {
           event: {
-            $type: 'tools.ozone.moderation.defs#modEventLabel',
+            $type: "tools.ozone.moderation.defs#modEventLabel",
             comment,
             createLabelVals: [label],
             negateLabelVals: [],
           },
           // specify the labeled post by strongRef
           subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
+            $type: "com.atproto.admin.defs#repoRef",
             did,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? '',
+          createdBy: agent.did ?? "",
           createdAt: new Date().toISOString(),
         },
         {
-          encoding: 'application/json',
+          encoding: "application/json",
           headers: {
-            'atproto-proxy': `${MOD_DID}#atproto_labeler`,
-            'atproto-accept-labelers':
-              'did:plc:ar7c4by46qjdydhdevvrndac;redact',
+            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-accept-labelers":
+              "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
···
       return await agent.tools.ozone.moderation.emitEvent(
         {
           event: {
-            $type: 'tools.ozone.moderation.defs#modEventReport',
+            $type: "tools.ozone.moderation.defs#modEventReport",
             comment,
-            reportType: 'com.atproto.moderation.defs#reasonOther',
+            reportType: "com.atproto.moderation.defs#reasonOther",
           },
           // specify the labeled post by strongRef
           subject: {
-            $type: 'com.atproto.repo.strongRef',
+            $type: "com.atproto.repo.strongRef",
             uri,
             cid,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? '',
+          createdBy: agent.did ?? "",
           createdAt: new Date().toISOString(),
         },
         {
-          encoding: 'application/json',
+          encoding: "application/json",
           headers: {
-            'atproto-proxy': `${MOD_DID}#atproto_labeler`,
-            'atproto-accept-labelers':
-              'did:plc:ar7c4by46qjdydhdevvrndac;redact',
+            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-accept-labelers":
+              "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
···
       await agent.tools.ozone.moderation.emitEvent(
         {
           event: {
-            $type: 'tools.ozone.moderation.defs#modEventComment',
+            $type: "tools.ozone.moderation.defs#modEventComment",
             comment,
           },
           // specify the labeled post by strongRef
           subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
+            $type: "com.atproto.admin.defs#repoRef",
             did,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? '',
+          createdBy: agent.did ?? "",
           createdAt: new Date().toISOString(),
         },
         {
-          encoding: 'application/json',
+          encoding: "application/json",
           headers: {
-            'atproto-proxy': `${MOD_DID}#atproto_labeler`,
-            'atproto-accept-labelers':
-              'did:plc:ar7c4by46qjdydhdevvrndac;redact',
+            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-accept-labelers":
+              "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
···
       await agent.tools.ozone.moderation.emitEvent(
         {
           event: {
-            $type: 'tools.ozone.moderation.defs#modEventReport',
+            $type: "tools.ozone.moderation.defs#modEventReport",
             comment,
-            reportType: 'com.atproto.moderation.defs#reasonOther',
+            reportType: "com.atproto.moderation.defs#reasonOther",
           },
           // specify the labeled post by strongRef
           subject: {
-            $type: 'com.atproto.admin.defs#repoRef',
+            $type: "com.atproto.admin.defs#repoRef",
             did,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? '',
+          createdBy: agent.did ?? "",
           createdAt: new Date().toISOString(),
         },
         {
-          encoding: 'application/json',
+          encoding: "application/json",
           headers: {
-            'atproto-proxy': `${MOD_DID}#atproto_labeler`,
-            'atproto-accept-labelers':
-              'did:plc:ar7c4by46qjdydhdevvrndac;redact',
+            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-accept-labelers":
+              "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
···
   await limit(async () => {
     try {
       await agent.com.atproto.repo.createRecord({
-        collection: 'app.bsky.graph.listitem',
+        collection: "app.bsky.graph.listitem",
         repo: MOD_DID,
         record: {
           subject: did,

src/monitor.ts

···
-import { describe } from 'node:test';
-
-import { PROFILE_CHECKS } from './constants.js';
-import logger from './logger.js';
-import { createAccountReport, createAccountLabel } from './moderation.js';
+import { describe } from "node:test";
+import { PROFILE_CHECKS } from "./constants.js";
+import logger from "./logger.js";
+import { createAccountReport, createAccountLabel } from "./moderation.js";
 
 export const monitorDescription = async (
   did: string,
···
     // Check if DID is whitelisted
     if (checkProfiles?.ignoredDIDs) {
       if (checkProfiles.ignoredDIDs.includes(did)) {
-        logger.info(`Whitelisted DID: ${did}`); return;
+        return logger.info(`Whitelisted DID: ${did}`);
       }
     }
 
     if (description) {
       if (checkProfiles?.description === true) {
-        if (checkProfiles.check.test(description)) {
-          if (checkProfiles.whitelist) {
-            if (checkProfiles.whitelist.test(description)) {
-              logger.info('Whitelisted phrase found.');
+        if (checkProfiles!.check.test(description)) {
+          if (checkProfiles!.whitelist) {
+            if (checkProfiles!.whitelist.test(description)) {
+              logger.info(`Whitelisted phrase found.`);
               return;
             }
           } else {
-            logger.info(`${checkProfiles.label} in description for ${did}`);
+            logger.info(`${checkProfiles!.label} in description for ${did}`);
           }
 
-          if (checkProfiles.reportOnly === true) {
+          if (checkProfiles!.reportOnly === true) {
             createAccountReport(
               did,
-              `${time}: ${checkProfiles.comment} - ${displayName} - ${description}`,
+              `${time}: ${checkProfiles!.comment} - ${displayName} - ${description}`,
             );
             return;
           } else {
             createAccountLabel(
               did,
-              checkProfiles.label,
-              `${time}: ${checkProfiles.comment}`,
+              `${checkProfiles!.label}`,
+              `${time}: ${checkProfiles!.comment}`,
             );
           }
         }
···
     // Check if DID is whitelisted
     if (checkProfiles?.ignoredDIDs) {
       if (checkProfiles.ignoredDIDs.includes(did)) {
-        logger.info(`Whitelisted DID: ${did}`); return;
+        return logger.info(`Whitelisted DID: ${did}`);
       }
     }
 
     if (displayName) {
       if (checkProfiles?.displayName === true) {
-        if (checkProfiles.check.test(displayName)) {
-          if (checkProfiles.whitelist) {
-            if (checkProfiles.whitelist.test(displayName)) {
-              logger.info('Whitelisted phrase found.');
+        if (checkProfiles!.check.test(displayName)) {
+          if (checkProfiles!.whitelist) {
+            if (checkProfiles!.whitelist.test(displayName)) {
+              logger.info(`Whitelisted phrase found.`);
               return;
             }
           } else {
-            logger.info(`${checkProfiles.label} in displayName for ${did}`);
+            logger.info(`${checkProfiles!.label} in displayName for ${did}`);
           }
 
-          if (checkProfiles.reportOnly === true) {
+          if (checkProfiles!.reportOnly === true) {
             createAccountReport(
               did,
-              `${time}: ${checkProfiles.comment} - ${displayName} - ${description}`,
+              `${time}: ${checkProfiles!.comment} - ${displayName} - ${description}`,
             );
             return;
           } else {
             createAccountLabel(
               did,
-              checkProfiles.label,
-              `${time}: ${checkProfiles.comment}`,
+              `${checkProfiles!.label}`,
+              `${time}: ${checkProfiles!.comment}`,
             );
           }
         }

src/types.ts

···
 
 // Define the type for the link feature
 export interface LinkFeature {
-  $type: 'app.bsky.richtext.facet#link';
+  $type: "app.bsky.richtext.facet#link";
   uri: string;
 }
 

src/utils.ts

···
-import logger from './logger.js';
+import logger from "./logger.js";
+
+import { homoglyphMap } from "./homoglyphs";
 
-/*  Normalize the Unicode characters: this doesn't consistently work yet, there is something about certain bluesky strings that causes it to fail. */
+/**
+ * Normalizes a string by converting it to lowercase, replacing homoglyphs,
+ * and stripping diacritics. This is useful for sanitizing user input
+ * before performing checks for forbidden words.
+ *
+ * The process is as follows:
+ * 1. Convert the entire string to lowercase.
+ * 2. Replace characters that are visually similar to ASCII letters (homoglyphs)
+ *    with their ASCII counterparts based on the `homoglyphMap`.
+ * 3. Apply NFD (Normalization Form D) Unicode normalization to decompose
+ *    characters into their base characters and combining marks.
+ * 4. Remove all Unicode combining diacritical marks.
+ * 5. Apply NFKC (Normalization Form KC) Unicode normalization for a final
+ *    cleanup, which handles compatibility characters.
+ *
+ * @param text The input string to normalize.
+ * @returns The normalized string.
+ */
 export function normalizeUnicode(text: string): string {
-  // First decompose the characters (NFD)
-  const decomposed = text.normalize('NFD');
+  // Convert to lowercase to match the homoglyph map keys
+  const lowercased = text.toLowerCase();
 
-  // Remove diacritics and combining marks
-  const withoutDiacritics = decomposed.replace(/[\u0300-\u036f]/g, '');
+  // Replace characters using the homoglyph map.
+  // This is done before NFD so that pre-composed characters are caught.
+  let replaced = "";
+  for (const char of lowercased) {
+    replaced += homoglyphMap[char] || char;
+  }
 
-  // Remove mathematical alphanumeric symbols
-  const withoutMath = withoutDiacritics.replace(
-    /[\uD835][\uDC00-\uDFFF]/g,
-    (char) => {
-      // Get the base character from the mathematical symbol
-      const code = char.codePointAt(0);
-      if (code >= 0x1d400 && code <= 0x1d433)
-        // Mathematical bold
-        return String.fromCharCode(code - 0x1d400 + 0x41);
-      if (code >= 0x1d434 && code <= 0x1d467)
-        // Mathematical italic
-        return String.fromCharCode(code - 0x1d434 + 0x61);
-      if (code >= 0x1d468 && code <= 0x1d49b)
-        // Mathematical bold italic
-        return String.fromCharCode(code - 0x1d468 + 0x41);
-      if (code >= 0x1d49c && code <= 0x1d4cf)
-        // Mathematical script
-        return String.fromCharCode(code - 0x1d49c + 0x61);
-      return char;
-    },
-  );
+  // First decompose the characters (NFD), then remove diacritics.
+  const withoutDiacritics = replaced
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "");
 
-  // Final NFKC normalization to handle any remaining special characters
-  return withoutMath.normalize('NFKC');
+  // Final NFKC normalization to handle any remaining special characters.
+  return withoutDiacritics.normalize("NFKC");
 }
 
 export async function getFinalUrl(url: string): Promise<string> {
   const controller = new AbortController();
-  const timeoutId = setTimeout(() => { controller.abort(); }, 10000); // 10-second timeout
+  const timeoutId = setTimeout(() => controller.abort(), 10000); // 10-second timeout
 
   try {
     const response = await fetch(url, {
-      method: 'HEAD',
-      redirect: 'follow', // This will follow redirects automatically
+      method: "HEAD",
+      redirect: "follow", // This will follow redirects automatically
       signal: controller.signal, // Pass the abort signal to fetch
     });
     clearTimeout(timeoutId); // Clear the timeout if fetch completes
···
   } catch (error) {
     clearTimeout(timeoutId); // Clear the timeout if fetch fails
     // Log the error with more specific information if it's a timeout
-    if (error instanceof Error && error.name === 'AbortError') {
+    if (error instanceof Error && error.name === "AbortError") {
       logger.warn(`Timeout fetching URL: ${url}`, error);
     } else {
       logger.warn(`Error fetching URL: ${url}`, error);
···
 }
 
 export async function getLanguage(profile: string): Promise<string> {
-  if (!profile) {
+  if (typeof profile !== "string" || profile === null) {
     logger.warn(
-      '[GETLANGUAGE] getLanguage called with empty profile data, defaulting to \'eng\'.',
+      "[GETLANGUAGE] getLanguage called with invalid profile data, defaulting to 'eng'.",
       profile,
     );
-    return 'eng'; // Default or throw an error
+    return "eng"; // Default or throw an error
   }
 
   const profileText = profile.trim();
 
   if (profileText.length === 0) {
-    return 'eng';
+    return "eng";
   }
 
-  try {
-    const lande = (await import('lande')).default;
-    const langsProbabilityMap = lande(profileText);
+  const lande = (await import("lande")).default;
+  let langsProbabilityMap = lande(profileText);
 
-    // Sort by probability in descending order
-    langsProbabilityMap.sort(
-      (a: [string, number], b: [string, number]) => b[1] - a[1],
-    );
+  // Sort by probability in descending order
+  langsProbabilityMap.sort(
+    (a: [string, number], b: [string, number]) => b[1] - a[1],
+  );
 
-    // Return the language code with the highest probability
-    return langsProbabilityMap[0][0];
-  } catch (error) {
-    logger.error('Error detecting language, defaulting to \'eng\':', error);
-    return 'eng'; // Fallback to English on error
-  }
+  // Return the language code with the highest probability
+  return langsProbabilityMap[0][0];
 }

src/validateEnv.ts

···
-import logger from './logger.js';
+import logger from "./logger.js";
 
 interface EnvironmentVariable {
   name: string;
···
 
 const ENV_VARIABLES: EnvironmentVariable[] = [
   {
-    name: 'DID',
+    name: "DID",
     required: true,
-    description: 'Moderator DID for labeling operations',
-    validator: (value) => value.startsWith('did:'),
+    description: "Moderator DID for labeling operations",
+    validator: (value) => value.startsWith("did:"),
   },
   {
-    name: 'OZONE_URL',
+    name: "OZONE_URL",
     required: true,
-    description: 'Ozone server URL',
-    validator: (value) => value.includes('.') && value.length > 3,
+    description: "Ozone server URL",
+    validator: (value) => value.includes(".") && value.length > 3,
   },
   {
-    name: 'OZONE_PDS',
+    name: "OZONE_PDS",
     required: true,
-    description: 'Ozone PDS URL',
-    validator: (value) => value.includes('.') && value.length > 3,
+    description: "Ozone PDS URL",
+    validator: (value) => value.includes(".") && value.length > 3,
   },
   {
-    name: 'BSKY_HANDLE',
+    name: "BSKY_HANDLE",
     required: true,
-    description: 'Bluesky handle for authentication',
-    validator: (value) => value.includes('.'),
+    description: "Bluesky handle for authentication",
+    validator: (value) => value.includes("."),
   },
   {
-    name: 'BSKY_PASSWORD',
+    name: "BSKY_PASSWORD",
     required: true,
-    description: 'Bluesky password for authentication',
+    description: "Bluesky password for authentication",
     validator: (value) => value.length > 0,
   },
   {
-    name: 'HOST',
+    name: "HOST",
     required: false,
-    description: 'Host address for the server (defaults to 127.0.0.1)',
+    description: "Host address for the server (defaults to 127.0.0.1)",
   },
   {
-    name: 'PORT',
+    name: "PORT",
     required: false,
-    description: 'Port for the main server (defaults to 4100)',
+    description: "Port for the main server (defaults to 4100)",
     validator: (value) => !isNaN(Number(value)) && Number(value) > 0,
   },
   {
-    name: 'METRICS_PORT',
+    name: "METRICS_PORT",
     required: false,
-    description: 'Port for metrics server (defaults to 4101)',
+    description: "Port for metrics server (defaults to 4101)",
     validator: (value) => !isNaN(Number(value)) && Number(value) > 0,
   },
   {
-    name: 'FIREHOSE_URL',
+    name: "FIREHOSE_URL",
     required: false,
-    description: 'Jetstream firehose WebSocket URL',
-    validator: (value) => value.startsWith('ws'),
+    description: "Jetstream firehose WebSocket URL",
+    validator: (value) => value.startsWith("ws"),
   },
   {
-    name: 'CURSOR_UPDATE_INTERVAL',
+    name: "CURSOR_UPDATE_INTERVAL",
     required: false,
-    description: 'Cursor update interval in milliseconds (defaults to 60000)',
+    description: "Cursor update interval in milliseconds (defaults to 60000)",
     validator: (value) => !isNaN(Number(value)) && Number(value) > 0,
   },
   {
-    name: 'LABEL_LIMIT',
+    name: "LABEL_LIMIT",
     required: false,
-    description: 'Rate limit for labeling operations',
+    description: "Rate limit for labeling operations",
     validator: (value) => {
       // Allow "number * number" format or plain numbers
       const multiplyMatch = /^(\d+)\s*\*\s*(\d+)$/.exec(value);
···
     },
   },
   {
-    name: 'LABEL_LIMIT_WAIT',
+    name: "LABEL_LIMIT_WAIT",
     required: false,
-    description: 'Wait time between rate limited operations',
+    description: "Wait time between rate limited operations",
     validator: (value) => {
       // Allow "number * number" format or plain numbers
       const multiplyMatch = /^(\d+)\s*\*\s*(\d+)$/.exec(value);
···
     },
   },
   {
-    name: 'LOG_LEVEL',
+    name: "LOG_LEVEL",
     required: false,
-    description: 'Logging level (trace, debug, info, warn, error, fatal)',
+    description: "Logging level (trace, debug, info, warn, error, fatal)",
     validator: (value) =>
-      ['trace', 'debug', 'info', 'warn', 'error', 'fatal'].includes(value),
+      ["trace", "debug", "info", "warn", "error", "fatal"].includes(value),
   },
   {
-    name: 'NODE_ENV',
+    name: "NODE_ENV",
     required: false,
-    description: 'Node environment (development, production, test)',
-    validator: (value) => ['development', 'production', 'test'].includes(value),
+    description: "Node environment (development, production, test)",
+    validator: (value) => ["development", "production", "test"].includes(value),
   },
 ];
 
···
   const errors: string[] = [];
   const warnings: string[] = [];
 
-  logger.info('Validating environment variables...');
+  logger.info("Validating environment variables...");
 
   for (const envVar of ENV_VARIABLES) {
     const value = process.env[envVar.name];
 
     if (envVar.required) {
-      if (!value || value.trim() === '') {
+      if (!value || value.trim() === "") {
         errors.push(
-          `Required environment variable ${envVar.name} is missing. ${envVar.description}`
+          `Required environment variable ${envVar.name} is missing. ${envVar.description}`,
         );
         continue;
       }
···
       try {
         if (!envVar.validator(value)) {
           errors.push(
-            `Environment variable ${envVar.name} has invalid format. ${envVar.description}`
+            `Environment variable ${envVar.name} has invalid format. ${envVar.description}`,
           );
         }
       } catch (error) {
         errors.push(
-          `Environment variable ${envVar.name} validation failed: ${String(error)}. ${envVar.description}`
+          `Environment variable ${envVar.name} validation failed: ${String(error)}. ${envVar.description}`,
         );
       }
     }
 
     if (!envVar.required && !value) {
       warnings.push(
-        `Optional environment variable ${envVar.name} not set, using default. ${envVar.description}`
+        `Optional environment variable ${envVar.name} not set, using default. ${envVar.description}`,
       );
     }
   }
 
   if (warnings.length > 0) {
-    logger.warn('Environment variable warnings:');
-    warnings.forEach((warning) => { logger.warn(`  - ${warning}`); });
+    logger.warn("Environment variable warnings:");
+    warnings.forEach((warning) => {
+      logger.warn(`  - ${warning}`);
+    });
   }
 
   if (errors.length > 0) {
-    logger.error('Environment variable validation failed:');
-    errors.forEach((error) => { logger.error(`  - ${error}`); });
-    logger.error('Please check your environment configuration and try again.');
+    logger.error("Environment variable validation failed:");
+    errors.forEach((error) => {
+      logger.error(`  - ${error}`);
+    });
+    logger.error("Please check your environment configuration and try again.");
     process.exit(1);
   }
 
-  logger.info('Environment variable validation completed successfully');
-}
+  logger.info("Environment variable validation completed successfully");
+}