More command manager improvements

src/app/CommandManager.ts

@@ -1,15 +1,14 @@
 import * as readline from 'readline';
 import * as fs from 'fs';
 import * as path from 'path';
-import {Server} from "socket.io";
-import * as os from 'os';
+import { Server } from 'socket.io';
 
 class CommandManager {
     private commands: Map<string, Function> = new Map();
     private rl: readline.Interface;
-    private io: Server|null = null;
+    private io: Server | null = null;
 
-    public constructor() {
+    constructor() {
         this.rl = readline.createInterface({
             input: process.stdin,
             output: process.stdout
@@ -17,45 +16,55 @@ class CommandManager {
     }
 
     public async boot(io: Server) {
-        // Start the command manager
-        this.io = io as Server;
+        this.io = io;
         await this.loadCommands();
         console.log('[✅] Command manager loaded');
-
-        // Start the prompt
-        await this.startPrompt();
+        this.startPrompt();
     }
 
-    private async startPrompt() {
+    private startPrompt() {
         this.rl.question('> ', (command: string) => {
             this.processCommand(command);
             this.startPrompt();
         });
     }
 
-    private async processCommand(command: string): Promise<any> {
+    private async processCommand(command: string): Promise<void> {
         const [cmd, ...args] = command.trim().toLowerCase().split(' ');
         if (this.commands.has(cmd)) {
             this.commands.get(cmd)?.(args, this.io as Server);
         } else {
-            switch (cmd) {
+            this.handleUnknownCommand(cmd);
+        }
+    }
+
+    private handleUnknownCommand(command: string) {
+        switch (command) {
             case 'exit':
                 console.log('Goodbye!');
                 this.rl.close();
                 process.exit(0);
                 break;
             default:
-                    console.log(`Unknown command: ${command}`);
+                console.error(`Unknown command: ${command}`);
                 break;
         }
     }
-    }
 
     private async loadCommands() {
         const commandsDir = path.resolve(__dirname, 'commands');
+        try {
             const files: string[] = await fs.promises.readdir(commandsDir);
 
             for (const file of files) {
+                await this.loadCommand(commandsDir, file);
+            }
+        } catch (error) {
+            console.error('[❌] Failed to read commands directory:', error);
+        }
+    }
+
+    private async loadCommand(commandsDir: string, file: string) {
         try {
             const ext = path.extname(file);
             const commandName = path.basename(file, ext);
@@ -63,9 +72,8 @@ class CommandManager {
             const module = await import(commandPath);
 
             this.registerCommand(commandName, module.default);
-            } catch (error: any) {
-                console.error('[❌] Failed to load file:', file, error);
-            }
+        } catch (error) {
+            console.error('[❌] Failed to load command:', file, error);
         }
     }