@manch1kz/yanac 1.0.3 → 1.0.5

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "tabWidth": 4,
+  "useTabs": false
+}

package/README.md

@@ -14,6 +14,8 @@ Starting the сlient:
 yanac start client [options]
 ```
 
+Type ```/help``` in chat to see all commands 
+
 Options for server:
 * ```--port <limit>``` - port (default: 3000)
 * ```--limit <limit>``` - chat maximum size (default: 100)
@@ -23,6 +25,12 @@ Options for client:
 * ```--host <limit>``` - host (default: default)
 * ```--name <limit>``` - port (default: random_string)
 
+## Demonstration
+
+https://github.com/user-attachments/assets/2d44a7cc-3b39-4c13-bada-8d6654053ac2
+
+
+
 
 
 

package/build/client/clientInstance.js

@@ -21,16 +21,32 @@ class Client {
         this.server = net_1.default.connect({ host: host, port: port });
         this.key_generated = false;
         this.manager = new sessionManager_1.SessionManager();
-        this.rl = promises_1.default.createInterface({ input: process.stdin, output: process.stdout, prompt: `${this.name} >>> ` });
+        this.rl = promises_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: `${this.name} >>> `,
+        });
         this.server.on("connect", () => {
-            this.server.write(JSON.stringify({ type: 'public_key_request', body: this.manager.getClient() }));
+            this.server.write(JSON.stringify({
+                type: "public_key_request",
+                body: this.manager.getClient(),
+            }));
         });
         this.server.on("data", (data) => {
             processMessage_1.processMessage.call(this, data);
         });
         this.rl.on("line", mainInputHandler_1.onLine.bind(this));
-        this.server.on("close", () => { this.server.end(); process.exit(); });
-        this.rl.on("SIGINT", () => { this.server.end(); process.exit(); });
+        this.server.on("error", () => {
+            console.log("\nServer closed or doesn't exist :(");
+        });
+        this.server.on("close", () => {
+            this.server.end();
+            process.exit();
+        });
+        this.rl.on("SIGINT", () => {
+            this.server.end();
+            process.exit();
+        });
     }
 }
 exports.Client = Client;

package/build/client/commands/ClientCommandHandler.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processEnteredCommand = processEnteredCommand;
+const edUtils_1 = require("../../utils/edUtils");
+function processEnteredCommand(command) {
+    let formated = command.slice(1, command.length);
+    switch (formated) {
+        case "exit":
+            this.rl.emit("SIGINT");
+            break;
+        case "help":
+            console.log("/help - show this menu\n/ping - check ping\n/online - check count of users online");
+            this.rl.prompt();
+            break;
+        case "online":
+        case "ping":
+            this.server.write((0, edUtils_1.encrypt)(JSON.stringify({ type: "command", body: formated }), this.manager.session_key));
+            break;
+        default:
+            console.log("No command found");
+            this.rl.prompt();
+    }
+}

package/build/client/handlers/mainInputHandler.js

@@ -2,20 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.onLine = onLine;
 const edUtils_1 = require("../../utils/edUtils");
+const clientCommandHandler_1 = require("../commands/clientCommandHandler");
 function onLine(line) {
     if (line.length > 0) {
         process.stdout.moveCursor(0, -1);
-        process.stdout.write('\r\x1B[K');
+        process.stdout.write("\r\x1B[K");
         console.log(`${this.name}: ${line}`);
-        if (line == "/exit") {
-            this.rl.emit("SIGINT");
+        if (line.startsWith("/")) {
+            clientCommandHandler_1.processEnteredCommand.call(this, line);
+            return;
         }
-        this.server.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'msg', body: [this.name, line] }), this.manager.session_key));
+        this.server.write((0, edUtils_1.encrypt)(JSON.stringify({ type: "msg", body: [this.name, line] }), this.manager.session_key));
         this.rl.prompt();
     }
     else {
         process.stdout.moveCursor(0, -1);
-        process.stdout.write('\r\x1B[K');
+        process.stdout.write("\r\x1B[K");
         this.rl.prompt();
     }
 }

package/build/client/handlers/processMessage.js

@@ -7,35 +7,44 @@ async function processMessage(data) {
     let processed;
     if (this.key_generated) {
         processed = JSON.parse((0, edUtils_1.decrypt)(data.toString(), this.manager.session_key));
+        process.stdout.write("\r\x1B[K");
     }
     else {
-        processed = JSON.parse(data.toString('utf-8'));
+        processed = JSON.parse(data.toString("utf-8"));
     }
     switch (processed.type) {
-        case 'public_key_response':
+        case "public_key_response":
             this.manager.setServer(processed.body[1]);
-            this.server.write(JSON.stringify({ type: 'master_key_response', body: [this.manager.getMaster(processed.body[0]), this.name] }));
+            this.server.write(JSON.stringify({
+                type: "master_key_response",
+                body: [
+                    this.manager.getMaster(processed.body[0]),
+                    this.name,
+                ],
+            }));
             break;
-        case 'finished':
+        case "finished":
             this.manager.generateSession();
             this.key_generated = true;
             this.server.write((0, edUtils_1.encrypt)(JSON.stringify({ type: "finished", body: this.name }), this.manager.session_key));
-            this.rl.prompt();
             break;
-        case 'history':
-            process.stdout.write('\r\x1B[K');
-            for (let i = 0; i < processed.body.length; i++) {
-                console.log(processed.body[i][0] + ':', processed.body[i][1]);
+        case "history":
+            let historyLength = processed.body.length;
+            for (let i = 0; i < historyLength; i++) {
+                console.log(processed.body[i][0] + ":", processed.body[i][1]);
             }
-            console.log('[SERVER]:', this.name, 'connected to server');
-            this.rl.prompt(true);
-            process.stdout.cursorTo(cur.cols);
+            console.log("[SERVER]:", this.name, "connected to server");
             break;
-        case 'msg':
-            process.stdout.write('\r\x1B[K');
-            console.log(processed.data[0] + ':', processed.data[1]);
-            this.rl.prompt(true);
-            process.stdout.cursorTo(cur.cols);
+        case "msg":
+            console.log(processed.body[0] + ":", processed.body[1]);
+            break;
+        case "online":
+            console.log(processed.body);
+            break;
+        case "ping":
+            console.log(`Current ping is: ${Date.now() - Number(processed.body)}`);
             break;
     }
+    this.rl.prompt(true);
+    process.stdout.cursorTo(cur.cols);
 }

package/build/security/sessionManager.js

@@ -17,24 +17,30 @@ class SessionManager {
         this.server_random = null;
         this.master_random = null;
         this.session_key = null;
-        const { publicKey, privateKey } = crypto_1.default.generateKeyPairSync('rsa', {
+        const { publicKey, privateKey } = crypto_1.default.generateKeyPairSync("rsa", {
             modulusLength: 2048,
             publicKeyEncoding: {
-                format: 'pem',
-                type: 'pkcs1'
+                format: "pem",
+                type: "pkcs1",
             },
             privateKeyEncoding: {
-                format: 'pem',
-                type: 'pkcs1'
-            }
+                format: "pem",
+                type: "pkcs1",
+            },
         });
         this.privateKey = privateKey;
         this.publicKey = publicKey;
     }
     generateSession() {
         if (this.client_random && this.server_random && this.master_random) {
-            const sum = this.client_random + this.server_random + Number(this.master_random);
-            this.session_key = crypto_1.default.createHash('sha256').update(String(sum)).digest().toString('hex');
+            const sum = this.client_random +
+                this.server_random +
+                Number(this.master_random);
+            this.session_key = crypto_1.default
+                .createHash("sha256")
+                .update(String(sum))
+                .digest()
+                .toString("hex");
         }
     }
     setClient(client_random) {
@@ -59,16 +65,20 @@ class SessionManager {
         if (this.master_random == null) {
             this.master_random = String(Math.floor(Math.random() * 5000));
         }
-        return crypto_1.default.publicEncrypt({
+        return crypto_1.default
+            .publicEncrypt({
             key: public_key,
             padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
-        }, this.master_random).toString('base64');
+        }, this.master_random)
+            .toString("base64");
     }
     setMaster(master_random, private_key) {
-        this.master_random = crypto_1.default.privateDecrypt({
+        this.master_random = crypto_1.default
+            .privateDecrypt({
             key: private_key,
             padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
-        }, Buffer.from(master_random, 'base64')).toString();
+        }, Buffer.from(master_random, "base64"))
+            .toString();
     }
 }
 exports.SessionManager = SessionManager;

package/build/server/handlers/processMessage.js

@@ -2,47 +2,52 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processMessage = processMessage;
 const edUtils_1 = require("../../utils/edUtils");
+const serverCommandHandler_1 = require("./serverCommandHandler");
+function broadcast(body, exclude = []) {
+    let stringifyed = JSON.stringify({ type: "msg", body: body });
+    this.localChatStore.push(body);
+    for (let [connection, metadata] of this.connections) {
+        if (!exclude.includes(connection)) {
+            connection.write((0, edUtils_1.encrypt)(stringifyed, metadata.generator.session_key));
+        }
+    }
+}
 function processMessage(socket, data) {
     const socket_item = this.connections.get(socket);
     const socket_generator = socket_item.generator;
-    let message;
-    if (socket_item.key_generated) {
-        message = JSON.parse((0, edUtils_1.decrypt)(data.toString(), socket_item.generator.session_key));
-    }
-    else {
-        message = JSON.parse(data.toString());
-    }
+    let message = socket_item.key_generated
+        ? JSON.parse((0, edUtils_1.decrypt)(data.toString(), socket_generator.session_key))
+        : JSON.parse(data.toString());
     switch (message.type) {
-        case 'msg':
-            this.localChatStore.push(message.body);
-            Array.from(this.connections.keys()).forEach((i) => {
-                if (i != socket) {
-                    i.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'msg', data: message.body }), this.connections.get(i).generator.session_key));
-                }
-            });
+        case "msg":
+            broadcast.call(this, message.body, [socket]);
+            break;
+        case "command":
+            serverCommandHandler_1.processClientCommand.call(this, message.body, socket, socket_generator);
             break;
-        case 'public_key_request':
+        case "finished":
+            socket_item.name = message.body;
+            socket.write((0, edUtils_1.encrypt)(JSON.stringify({
+                type: "history",
+                body: this.localChatStore.getChat(),
+            }), socket_generator.session_key));
+            broadcast.call(this, ["[SERVER]", message.body + " connected to server"], [socket]);
+            break;
+        case "public_key_request":
             const server_random = this.manager.getServer();
             socket_generator.setClient(message.body);
             socket_generator.setServer(server_random);
-            socket.write(JSON.stringify({ type: 'public_key_response', body: [this.manager.publicKey, server_random] }));
+            socket.write(JSON.stringify({
+                type: "public_key_response",
+                body: [this.manager.publicKey, server_random],
+            }));
             break;
-        case 'master_key_response':
+        case "master_key_response":
             socket_generator.setMaster(message.body[0], this.manager.privateKey);
             socket_generator.generateSession();
             socket_item.name = message.body[1];
             socket_item.key_generated = true;
-            socket.write(JSON.stringify({ type: 'finished' }));
-            break;
-        case 'finished':
-            socket_item.name = message.body;
-            socket.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'history', body: this.localChatStore.getChat() }), socket_generator.session_key));
-            this.localChatStore.push(['[SERVER]', message.body + ' connected to server']);
-            Array.from(this.connections.keys()).forEach((i) => {
-                if (i != socket) {
-                    i.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'msg', data: ['[SERVER]', message.body + ' connected to server'] }), this.connections.get(i).generator.session_key));
-                }
-            });
+            socket.write(JSON.stringify({ type: "finished" }));
             break;
     }
 }

package/build/server/handlers/serverCommandHandler.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processClientCommand = processClientCommand;
+const edUtils_1 = require("../../utils/edUtils");
+function processClientCommand(command, socket, socket_generator) {
+    switch (command) {
+        case "online":
+            socket.write((0, edUtils_1.encrypt)(JSON.stringify({
+                type: "online",
+                body: `Current connections: ${this.connections.size}`,
+            }), socket_generator.session_key));
+            break;
+        case "ping":
+            socket.write((0, edUtils_1.encrypt)(JSON.stringify({ type: "ping", body: Date.now() }), socket_generator.session_key));
+            break;
+    }
+}

package/build/server/handlers/setupSocket.js

@@ -4,17 +4,22 @@ exports.setupSocket = setupSocket;
 const sessionManager_1 = require("../../security/sessionManager");
 const edUtils_1 = require("../../utils/edUtils");
 function setupSocket(socket, cb) {
-    this.connections.set(socket, { name: null, generator: new sessionManager_1.SessionManager(), key_generated: false });
-    socket.on('close', () => {
-        let body = ['[SERVER]', this.connections.get(socket).name + ' disconnected from server'];
+    this.connections.set(socket, {
+        name: null,
+        generator: new sessionManager_1.SessionManager(),
+        key_generated: false,
+    });
+    socket.on("close", () => {
+        let name = this.connections.get(socket).name;
+        let body = ["[SERVER]", name + " disconnected from server"];
         this.localChatStore.push(body);
-        Array.from(this.connections.keys()).forEach((i) => {
-            i.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'msg', data: body }), this.connections.get(i).generator.session_key));
-        });
+        for (let [connection, metadata] of this.connections) {
+            connection.write((0, edUtils_1.encrypt)(JSON.stringify({ type: "msg", body: body }), metadata.generator.session_key));
+        }
         this.connections.delete(socket);
     });
     socket.on("error", () => { });
-    socket.on('data', (data) => {
+    socket.on("data", (data) => {
         cb(socket, data);
     });
 }

package/build/server/serverInstance.js

@@ -14,15 +14,26 @@ class Server {
     server;
     manager;
     connections;
+    cur;
     constructor(limit = 100, port = 3000) {
-        this.localChatStore = new localChatStore_1.LocalChatStore(100);
+        this.localChatStore = new localChatStore_1.LocalChatStore(limit);
         this.manager = new sessionManager_1.SessionManager();
         this.connections = new Map();
         this.server = net_1.default.createServer();
+        this.cur = Promise.resolve();
         this.server.on("connection", (socket) => {
-            setupSocket_1.setupSocket.call(this, socket, processMessage_1.processMessage.bind(this));
+            this.add(() => {
+                setupSocket_1.setupSocket.call(this, socket, processMessage_1.processMessage.bind(this));
+            });
         });
         this.server.listen(port);
+        console.log("Server is listening...\nPress CTRL + C to stop server\n");
+    }
+    add(cb) {
+        this.cur = this.cur.then(async () => {
+            await cb();
+            await new Promise((res) => setTimeout(res, 500));
+        });
     }
 }
 exports.Server = Server;

package/client/clientInstance.ts

@@ -1,34 +1,52 @@
-import net from 'net'
-import readline from 'readline/promises'
-import { SessionManager } from '../security/sessionManager'
-import { processMessage } from './handlers/processMessage'
-import { onLine } from "./handlers/mainInputHandler"
-import { genName } from '../utils/genNameAlias'
+import net from "net";
+import readline from "readline/promises";
+import { SessionManager } from "../security/sessionManager";
+import { processMessage } from "./handlers/processMessage";
+import { onLine } from "./handlers/mainInputHandler";
+import { genName } from "../utils/genNameAlias";
 
 export class Client {
-    manager: SessionManager
-    rl: readline.Interface
-    name: string
-    server: net.Socket
-    key_generated: boolean
+    manager: SessionManager;
+    rl: readline.Interface;
+    name: string;
+    server: net.Socket;
+    key_generated: boolean;
 
-    constructor(name=genName(), host="localhost", port=3000) {
-        this.name = name
-        this.server = net.connect({ host: host, port: port })
-        this.key_generated = false
-        this.manager = new SessionManager()
-        this.rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: `${this.name} >>> ` })
+    constructor(name = genName(), host = "localhost", port = 3000) {
+        this.name = name;
+        this.server = net.connect({ host: host, port: port });
+        this.key_generated = false;
+        this.manager = new SessionManager();
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: `${this.name} >>> `,
+        });
 
         this.server.on("connect", () => {
-            this.server.write(JSON.stringify({type: 'public_key_request', body: this.manager.getClient()}))
-        })
+            this.server.write(
+                JSON.stringify({
+                    type: "public_key_request",
+                    body: this.manager.getClient(),
+                }),
+            );
+        });
         this.server.on("data", (data) => {
-            processMessage.call(this, data)
-        })
+            processMessage.call(this, data);
+        });
 
-        this.rl.on("line", onLine.bind(this))
+        this.rl.on("line", onLine.bind(this));
 
-        this.server.on("close", () => {this.server.end(); process.exit()})
-        this.rl.on("SIGINT", () => {this.server.end(); process.exit()})
+        this.server.on("error", () => {
+            console.log("\nServer closed or doesn't exist :(");
+        });
+        this.server.on("close", () => {
+            this.server.end();
+            process.exit();
+        });
+        this.rl.on("SIGINT", () => {
+            this.server.end();
+            process.exit();
+        });
     }
-}
+}

package/client/commands/clientCommandHandler.ts

@@ -0,0 +1,32 @@
+import { Client } from "../clientInstance";
+import { encrypt } from "../../utils/edUtils";
+
+function processEnteredCommand(this: Client, command: string) {
+    let formated = command.slice(1, command.length);
+
+    switch (formated) {
+        case "exit":
+            this.rl.emit("SIGINT");
+            break;
+        case "help":
+            console.log(
+                "/help - show this menu\n/ping - check ping\n/online - check count of users online",
+            );
+            this.rl.prompt();
+            break;
+        case "online":
+        case "ping":
+            this.server.write(
+                encrypt(
+                    JSON.stringify({ type: "command", body: formated }),
+                    this.manager.session_key,
+                ),
+            );
+            break;
+        default:
+            console.log("No command found");
+            this.rl.prompt();
+    }
+}
+
+export { processEnteredCommand };

package/client/handlers/mainInputHandler.ts

@@ -1,21 +1,30 @@
 import { Client } from "../clientInstance";
 import { encrypt } from "../../utils/edUtils";
+import { processEnteredCommand } from "../commands/clientCommandHandler";
 
 function onLine(this: Client, line: string) {
     if (line.length > 0) {
-        process.stdout.moveCursor(0, -1)
-        process.stdout.write('\r\x1B[K');
-        console.log(`${this.name}: ${line}`)
-        if (line == "/exit") {
-            this.rl.emit("SIGINT")
+        process.stdout.moveCursor(0, -1);
+        process.stdout.write("\r\x1B[K");
+        console.log(`${this.name}: ${line}`);
+
+        if (line.startsWith("/")) {
+            processEnteredCommand.call(this, line);
+            return;
         }
-        this.server.write(encrypt(JSON.stringify({type: 'msg', body: [this.name, line]}), this.manager.session_key))
-        this.rl.prompt()
+
+        this.server.write(
+            encrypt(
+                JSON.stringify({ type: "msg", body: [this.name, line] }),
+                this.manager.session_key,
+            ),
+        );
+        this.rl.prompt();
     } else {
-        process.stdout.moveCursor(0, -1)
-        process.stdout.write('\r\x1B[K');
-        this.rl.prompt()
+        process.stdout.moveCursor(0, -1);
+        process.stdout.write("\r\x1B[K");
+        this.rl.prompt();
     }
 }
 
-export { onLine }
+export { onLine };

package/client/handlers/processMessage.ts

@@ -1,47 +1,64 @@
-import { decrypt, encrypt } from "../../utils/edUtils"
-import { Client } from "../clientInstance"
+import { decrypt, encrypt } from "../../utils/edUtils";
+import { Client } from "../clientInstance";
 
 async function processMessage(this: Client, data: any) {
-    const cur = this.rl.getCursorPos()
-    let processed
+    const cur = this.rl.getCursorPos();
+    let processed;
 
     if (this.key_generated) {
-        processed = JSON.parse(decrypt(data.toString(), this.manager.session_key))
+        processed = JSON.parse(
+            decrypt(data.toString(), this.manager.session_key),
+        );
+        process.stdout.write("\r\x1B[K");
     } else {
-        processed = JSON.parse(data.toString('utf-8'))
+        processed = JSON.parse(data.toString("utf-8"));
     }
-   
+
     switch (processed.type) {
-        case 'public_key_response':
-            this.manager.setServer(processed.body[1])
-            this.server.write(JSON.stringify({type: 'master_key_response', body: [this.manager.getMaster(processed.body[0]), this.name]}))
+        case "public_key_response":
+            this.manager.setServer(processed.body[1]);
+            this.server.write(
+                JSON.stringify({
+                    type: "master_key_response",
+                    body: [
+                        this.manager.getMaster(processed.body[0]),
+                        this.name,
+                    ],
+                }),
+            );
             break;
-        case 'finished':
-            this.manager.generateSession()
-            this.key_generated = true
-            this.server.write(encrypt(JSON.stringify({type: "finished", body: this.name}), this.manager.session_key))
-            this.rl.prompt()
+        case "finished":
+            this.manager.generateSession();
+            this.key_generated = true;
+            this.server.write(
+                encrypt(
+                    JSON.stringify({ type: "finished", body: this.name }),
+                    this.manager.session_key,
+                ),
+            );
             break;
-        case 'history':
-            process.stdout.write('\r\x1B[K')
-
-            for (let i = 0; i < processed.body.length; i++) {
-                console.log(processed.body[i][0] + ':', processed.body[i][1])
+        case "history":
+            let historyLength = processed.body.length;
+            for (let i = 0; i < historyLength; i++) {
+                console.log(processed.body[i][0] + ":", processed.body[i][1]);
             }
-
-            console.log('[SERVER]:', this.name, 'connected to server')
-
-            this.rl.prompt(true)
-            process.stdout.cursorTo(cur.cols)
+            console.log("[SERVER]:", this.name, "connected to server");
             break;
-        case 'msg':
-            process.stdout.write('\r\x1B[K');
-            console.log(processed.data[0] + ':', processed.data[1])
-
-            this.rl.prompt(true)
-            process.stdout.cursorTo(cur.cols)
+        case "msg":
+            console.log(processed.body[0] + ":", processed.body[1]);
+            break;
+        case "online":
+            console.log(processed.body);
+            break;
+        case "ping":
+            console.log(
+                `Current ping is: ${Date.now() - Number(processed.body)}`,
+            );
             break;
     }
+
+    this.rl.prompt(true);
+    process.stdout.cursorTo(cur.cols);
 }
 
-export { processMessage }
+export { processMessage };

package/package.json

@@ -1,36 +1,36 @@
 {
-  "name": "@manch1kz/yanac",
-  "version": "1.0.3",
-  "description": "(YANAC) Yet another not another chat",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/manch1kz/YANAC"
-  },
-  "main": "./build/app.js",
-  "bin": "./build/app.js",
-  "scripts": {
-    "prepack": "npm run build",
-    "build": "tsc"
-  },
-  "keywords": [
-    "cryptography",
-    "handshake",
-    "tcp",
-    "educational",
-    "cli",
-    "security"
-  ],
-  "author": "manch1kz",
-  "license": "ISC",
-  "type": "commonjs",
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "commander": "^14.0.2"
-  },
-  "devDependencies": {
-    "@types/node": "^25.0.8",
-    "typescript": "^5.0.0"
-  }
+    "name": "@manch1kz/yanac",
+    "version": "1.0.5",
+    "description": "(YANAC) Yet another not another chat",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/manch1kz/YANAC"
+    },
+    "main": "./build/app.js",
+    "bin": "./build/app.js",
+    "scripts": {
+        "prepack": "npm run build",
+        "build": "tsc"
+    },
+    "keywords": [
+        "cryptography",
+        "handshake",
+        "tcp",
+        "educational",
+        "cli",
+        "security"
+    ],
+    "author": "manch1kz",
+    "license": "ISC",
+    "type": "commonjs",
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "commander": "^14.0.2"
+    },
+    "devDependencies": {
+        "@types/node": "^25.0.8",
+        "typescript": "^5.0.0"
+    }
 }

package/security/sessionManager.ts

@@ -1,78 +1,96 @@
-import crypto from "crypto"
+import crypto from "crypto";
 
 export class SessionManager {
-    client_random: any
-    server_random: any
-    master_random: any
-    session_key: any
-    privateKey: any
-    publicKey: any
+    client_random: any;
+    server_random: any;
+    master_random: any;
+    session_key: any;
+    privateKey: any;
+    publicKey: any;
 
     constructor() {
-        this.client_random = null
-        this.server_random = null
-        this.master_random = null
-        this.session_key = null
+        this.client_random = null;
+        this.server_random = null;
+        this.master_random = null;
+        this.session_key = null;
 
-        const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
+        const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
             modulusLength: 2048,
             publicKeyEncoding: {
-                format: 'pem',
-                type: 'pkcs1'
+                format: "pem",
+                type: "pkcs1",
             },
             privateKeyEncoding: {
-                format: 'pem',
-                type: 'pkcs1'
-            }})
+                format: "pem",
+                type: "pkcs1",
+            },
+        });
 
-        this.privateKey = privateKey
-        this.publicKey = publicKey
+        this.privateKey = privateKey;
+        this.publicKey = publicKey;
     }
 
     generateSession() {
         if (this.client_random && this.server_random && this.master_random) {
-            const sum = this.client_random + this.server_random + Number(this.master_random)
-            this.session_key = crypto.createHash('sha256').update(String(sum)).digest().toString('hex')
+            const sum =
+                this.client_random +
+                this.server_random +
+                Number(this.master_random);
+            this.session_key = crypto
+                .createHash("sha256")
+                .update(String(sum))
+                .digest()
+                .toString("hex");
         }
     }
 
     setClient(client_random: any) {
-        this.client_random = client_random
+        this.client_random = client_random;
     }
 
     getClient() {
         if (this.client_random == null) {
-            this.client_random = Math.floor(Math.random() * 5000)
+            this.client_random = Math.floor(Math.random() * 5000);
         }
-        return this.client_random
+        return this.client_random;
     }
 
     getServer() {
         if (this.server_random == null) {
-            this.server_random = Math.floor(Math.random() * 5000)
+            this.server_random = Math.floor(Math.random() * 5000);
         }
-        return this.server_random
+        return this.server_random;
     }
 
     setServer(server_random: any) {
-        this.server_random = server_random
+        this.server_random = server_random;
     }
 
     getMaster(public_key: any) {
         if (this.master_random == null) {
-            this.master_random = String(Math.floor(Math.random() * 5000))
+            this.master_random = String(Math.floor(Math.random() * 5000));
         }
 
-        return crypto.publicEncrypt({
-            key: public_key,
-            padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
-        }, this.master_random).toString('base64')  
+        return crypto
+            .publicEncrypt(
+                {
+                    key: public_key,
+                    padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+                },
+                this.master_random,
+            )
+            .toString("base64");
     }
 
     setMaster(master_random: any, private_key: any) {
-        this.master_random = crypto.privateDecrypt({
-            key: private_key,
-            padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
-        }, Buffer.from(master_random, 'base64')).toString()
+        this.master_random = crypto
+            .privateDecrypt(
+                {
+                    key: private_key,
+                    padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+                },
+                Buffer.from(master_random, "base64"),
+            )
+            .toString();
     }
-}
+}

package/server/handlers/processMessage.ts

@@ -1,57 +1,79 @@
-import { encrypt, decrypt } from "../../utils/edUtils"
-import { Server } from "../serverInstance"
+import { encrypt, decrypt } from "../../utils/edUtils";
+import { processClientCommand } from "./serverCommandHandler";
+import { Server } from "../serverInstance";
 
-function processMessage(this: Server, socket: any, data: any) {
-    const socket_item = this.connections.get(socket)
-    const socket_generator = socket_item.generator
-    let message
+function broadcast(this: Server, body: any, exclude = []) {
+    let stringifyed = JSON.stringify({ type: "msg", body: body });
+    this.localChatStore.push(body);
 
-    if (socket_item.key_generated) {
-        message = JSON.parse(decrypt(data.toString(), socket_item.generator.session_key))
-    } else {
-        message = JSON.parse(data.toString())
+    for (let [connection, metadata] of this.connections) {
+        if (!exclude.includes(connection)) {
+            connection.write(
+                encrypt(stringifyed, metadata.generator.session_key),
+            );
+        }
     }
+}
 
-    switch (message.type) {
-        case 'msg':
-            this.localChatStore.push(message.body)
-            Array.from(this.connections.keys()).forEach((i: any) => {
-                if (i != socket) {
-                    i.write(encrypt(JSON.stringify({type: 'msg', data: message.body}), this.connections.get(i).generator.session_key))
-                }
-            })
-            break;
-        case 'public_key_request':
-            const server_random = this.manager.getServer()
+function processMessage(this: Server, socket: any, data: any) {
+    const socket_item = this.connections.get(socket);
+    const socket_generator = socket_item.generator;
 
-            socket_generator.setClient(message.body)
-            socket_generator.setServer(server_random)
+    let message = socket_item.key_generated
+        ? JSON.parse(decrypt(data.toString(), socket_generator.session_key))
+        : JSON.parse(data.toString());
 
-            socket.write(JSON.stringify({type: 'public_key_response', body: [this.manager.publicKey, server_random]}))
+    switch (message.type) {
+        case "msg":
+            broadcast.call(this, message.body, [socket]);
             break;
-        case 'master_key_response':
-            socket_generator.setMaster(message.body[0], this.manager.privateKey)
-            socket_generator.generateSession()
-            socket_item.name = message.body[1]
-            socket_item.key_generated = true
-
-            socket.write(JSON.stringify({type: 'finished'}))
+        case "command":
+            processClientCommand.call(
+                this,
+                message.body,
+                socket,
+                socket_generator,
+            );
             break;
-        case 'finished':
-            socket_item.name = message.body
-            socket.write(encrypt(JSON.stringify({type: 'history', body: this.localChatStore.getChat()}), socket_generator.session_key))
-            this.localChatStore.push(['[SERVER]', message.body + ' connected to server'])
-
-            Array.from(this.connections.keys()).forEach((i: any) => {
-                if (i != socket) {
-                    i.write(
-                        encrypt(JSON.stringify({type: 'msg', data: ['[SERVER]', message.body + ' connected to server']}), 
-                        this.connections.get(i).generator.session_key)
-                    )
-                }
-            })
+        case "finished":
+            socket_item.name = message.body;
+            socket.write(
+                encrypt(
+                    JSON.stringify({
+                        type: "history",
+                        body: this.localChatStore.getChat(),
+                    }),
+                    socket_generator.session_key,
+                ),
+            );
+            broadcast.call(
+                this,
+                ["[SERVER]", message.body + " connected to server"],
+                [socket],
+            );
+            break;
+        case "public_key_request":
+            const server_random = this.manager.getServer();
+            socket_generator.setClient(message.body);
+            socket_generator.setServer(server_random);
+            socket.write(
+                JSON.stringify({
+                    type: "public_key_response",
+                    body: [this.manager.publicKey, server_random],
+                }),
+            );
+            break;
+        case "master_key_response":
+            socket_generator.setMaster(
+                message.body[0],
+                this.manager.privateKey,
+            );
+            socket_generator.generateSession();
+            socket_item.name = message.body[1];
+            socket_item.key_generated = true;
+            socket.write(JSON.stringify({ type: "finished" }));
             break;
     }
 }
 
-export { processMessage }
+export { processMessage };

package/server/handlers/serverCommandHandler.ts

@@ -0,0 +1,33 @@
+import { Server } from "../serverInstance";
+import { encrypt } from "../../utils/edUtils";
+
+function processClientCommand(
+    this: Server,
+    command: string,
+    socket: any,
+    socket_generator: any,
+) {
+    switch (command) {
+        case "online":
+            socket.write(
+                encrypt(
+                    JSON.stringify({
+                        type: "online",
+                        body: `Current connections: ${this.connections.size}`,
+                    }),
+                    socket_generator.session_key,
+                ),
+            );
+            break;
+        case "ping":
+            socket.write(
+                encrypt(
+                    JSON.stringify({ type: "ping", body: Date.now() }),
+                    socket_generator.session_key,
+                ),
+            );
+            break;
+    }
+}
+
+export { processClientCommand };

package/server/handlers/setupSocket.ts

@@ -1,26 +1,37 @@
-import { SessionManager } from "../../security/sessionManager"
-import { encrypt, decrypt } from "../../utils/edUtils"
-import { Server } from "../serverInstance"
-import net from 'net'
+import { SessionManager } from "../../security/sessionManager";
+import { encrypt, decrypt } from "../../utils/edUtils";
+import { Server } from "../serverInstance";
+import net from "net";
 
 function setupSocket(this: Server, socket: net.Socket, cb: Function) {
-    this.connections.set(socket, {name: null, generator: new SessionManager(), key_generated: false})
+    this.connections.set(socket, {
+        name: null,
+        generator: new SessionManager(),
+        key_generated: false,
+    });
 
-    socket.on('close', () => {
-        let body = ['[SERVER]', this.connections.get(socket).name + ' disconnected from server']
-        this.localChatStore.push(body)
+    socket.on("close", () => {
+        let name = this.connections.get(socket).name;
+        let body = ["[SERVER]", name + " disconnected from server"];
+        this.localChatStore.push(body);
 
-        Array.from(this.connections.keys()).forEach((i: any) => {
-            i.write(encrypt(JSON.stringify({type: 'msg', data: body}), this.connections.get(i).generator.session_key))
-        })
-        this.connections.delete(socket)
-    })
+        for (let [connection, metadata] of this.connections) {
+            connection.write(
+                encrypt(
+                    JSON.stringify({ type: "msg", body: body }),
+                    metadata.generator.session_key,
+                ),
+            );
+        }
 
-    socket.on("error", () => {}) 
+        this.connections.delete(socket);
+    });
 
-    socket.on('data', (data: any) => {
-        cb(socket, data)
-    })
+    socket.on("error", () => {});
+
+    socket.on("data", (data: any) => {
+        cb(socket, data);
+    });
 }
 
-export { setupSocket }
+export { setupSocket };

package/server/serverInstance.ts

@@ -1,25 +1,37 @@
-import net from 'net'
-import { SessionManager } from '../security/sessionManager'
-import { LocalChatStore } from '../utils/localChatStore'
-import { processMessage } from "./handlers/processMessage"
-import { setupSocket } from "./handlers/setupSocket"
+import net from "net";
+import { SessionManager } from "../security/sessionManager";
+import { LocalChatStore } from "../utils/localChatStore";
+import { processMessage } from "./handlers/processMessage";
+import { setupSocket } from "./handlers/setupSocket";
 
 export class Server {
-    localChatStore: LocalChatStore
-    server: net.Server
-    manager: SessionManager
-    connections: Map<any, any>
+    localChatStore: LocalChatStore;
+    server: net.Server;
+    manager: SessionManager;
+    connections: Map<any, any>;
+    cur: Promise<void>;
 
-    constructor(limit=100, port=3000) {
-        this.localChatStore = new LocalChatStore(100)
-        this.manager = new SessionManager()
-        this.connections = new Map()
-        this.server = net.createServer()
+    constructor(limit = 100, port = 3000) {
+        this.localChatStore = new LocalChatStore(limit);
+        this.manager = new SessionManager();
+        this.connections = new Map();
+        this.server = net.createServer();
+        this.cur = Promise.resolve();
 
         this.server.on("connection", (socket) => {
-            setupSocket.call(this, socket, processMessage.bind(this))
-        })
+            this.add(() => {
+                setupSocket.call(this, socket, processMessage.bind(this));
+            });
+        });
 
-        this.server.listen(port)
+        this.server.listen(port);
+        console.log("Server is listening...\nPress CTRL + C to stop server\n");
     }
-}
+
+    add(cb: Function) {
+        this.cur = this.cur.then(async () => {
+            await cb();
+            await new Promise((res) => setTimeout(res, 500));
+        });
+    }
+}

package/tsconfig.json

@@ -1,14 +1,14 @@
 {
-  "compilerOptions": {
-    "target": "es2022",
-    "module": "commonjs",
-    "rootDir": "./",
-    "outDir": "./build",
-    "sourceMap": false,
-    "declaration": false,
-    "declarationMap": false,
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-  },
-  "exclude": ["node_modules", "build"]
+    "compilerOptions": {
+        "target": "es2022",
+        "module": "commonjs",
+        "rootDir": "./",
+        "outDir": "./build",
+        "sourceMap": false,
+        "declaration": false,
+        "declarationMap": false,
+        "moduleResolution": "node",
+        "esModuleInterop": true
+    },
+    "exclude": ["node_modules", "build"]
 }