Revert "folder restructuring"

This reverts commit 17082597464198fe84be80313b7d51e1e57de639.

11 files changed, 698 insertions, 0 deletions

diff --git a/src/bin/client/connection.rs b/src/bin/client/connection.rs
new file mode 100644
index 0000000..497ed36
--- /dev/null
+++ b/src/bin/client/connection.rs
@@ -0,0 +1,57 @@
+use std::io::{BufRead, BufReader, Write};
+use std::net::TcpStream;
+use std::sync::mpsc;
+use std::thread;
+use std::time::{Duration, Instant};
+use rusqlite::Connection;
+use bcrypt::hash_with_salt;
+use crate::database;
+
+const SALT: [u8; 16] = *b"fixedsalt1234567";
+
+fn hash_password(password: &str) -> String {
+    let result = hash_with_salt(password, 10, SALT).unwrap();
+    result.to_string()
+}
+
+pub fn connect(addr: &str, conn: &Connection) -> Result<TcpStream, Box<dyn std::error::Error>> {
+    let (tx, rx) = mpsc::channel();
+    let addr_str = addr.to_string();
+    thread::spawn(move || {
+        match TcpStream::connect(&addr_str) {
+            Ok(s) => tx.send(Ok(s)).unwrap(),
+            Err(e) => tx.send(Err(e)).unwrap(),
+        }
+    });
+    match rx.recv_timeout(Duration::from_secs(3)) {
+        Ok(Ok(s)) => {
+            let mut ping_writer = s.try_clone().unwrap();
+            let mut ping_reader = BufReader::new(s.try_clone().unwrap());
+            let start = Instant::now();
+            writeln!(ping_writer, "PING").unwrap();
+            let mut response = String::new();
+            ping_reader.read_line(&mut response).unwrap();
+            let elapsed = start.elapsed();
+            println!("\n\rConnected to {} with ping delay: {:?}", addr, elapsed);
+            
+            // Check for credentials and auto-auth
+            if let Some((username, password)) = database::get_credentials(conn, addr) {
+                let hashed = hash_password(&password);
+                let auth_msg = format!("AUTH {} {}", username, hashed);
+                writeln!(ping_writer, "{}", auth_msg).unwrap();
+                let mut auth_response = String::new();
+                ping_reader.read_line(&mut auth_response).unwrap();
+                if auth_response.trim().starts_with("OK") {
+                    println!("Authenticated as {}", username);
+                } else {
+                    println!("Authentication failed: {}", auth_response.trim());
+                    // Do not fail, allow manual login
+                }
+            }
+            Ok(s)
+        }
+        Ok(Err(e)) => Err(Box::new(e)),
+        Err(mpsc::RecvTimeoutError::Timeout) => Err("Connection timed out after 3 seconds".into()),
+        Err(_) => Err("Connection attempt failed".into()),
+    }
+}
diff --git a/src/bin/client/database.rs b/src/bin/client/database.rs
new file mode 100644
index 0000000..03a6c45
--- /dev/null
+++ b/src/bin/client/database.rs
@@ -0,0 +1,94 @@
+use rusqlite::Connection;
+use aes_gcm::{Aes256Gcm, Key, Nonce};
+use aes_gcm::aead::{Aead, KeyInit};
+use pbkdf2::pbkdf2;
+use hmac::Hmac;
+use sha2::Sha256;
+use rand::Rng;
+
+pub fn init_db() -> Connection {
+    let conn = Connection::open("client.db").unwrap();
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS hosts (
+            host TEXT PRIMARY KEY,
+            last_used DATETIME DEFAULT CURRENT_TIMESTAMP
+        )",
+        [],
+    ).unwrap();
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS credentials (
+            host TEXT PRIMARY KEY,
+            username TEXT NOT NULL,
+            encrypted_password BLOB NOT NULL
+        )",
+        [],
+    ).unwrap();
+    conn
+}
+
+pub fn get_last_host(conn: &Connection) -> Option<String> {
+    let mut stmt = conn.prepare("SELECT host FROM hosts ORDER BY last_used DESC LIMIT 1").unwrap();
+    let mut rows = stmt.query([]).unwrap();
+    if let Ok(Some(row)) = rows.next() {
+        row.get(0).ok()
+    } else {
+        None
+    }
+}
+
+pub fn save_host(conn: &Connection, host: &str) {
+    conn.execute(
+        "INSERT OR REPLACE INTO hosts (host, last_used) VALUES (?1, CURRENT_TIMESTAMP)",
+        [host],
+    ).unwrap();
+}
+
+pub fn save_credentials(conn: &Connection, host: &str, username: &str, password: &str) -> Result<(), aes_gcm::Error> {
+    let encrypted = encrypt_password(password)?;
+    conn.execute(
+        "INSERT OR REPLACE INTO credentials (host, username, encrypted_password) VALUES (?1, ?2, ?3)",
+        (host, username, &encrypted),
+    ).unwrap();
+    Ok(())
+}
+
+pub fn get_credentials(conn: &Connection, host: &str) -> Option<(String, String)> {
+    let mut stmt = conn.prepare("SELECT username, encrypted_password FROM credentials WHERE host = ?1").unwrap();
+    let mut rows = stmt.query([host]).unwrap();
+    if let Ok(Some(row)) = rows.next() {
+        let username: String = row.get(0).unwrap();
+        let encrypted: Vec<u8> = row.get(1).unwrap();
+        decrypt_password(&encrypted).map(|password| (username, password))
+    } else {
+        None
+    }
+}
+
+fn derive_key() -> Key<Aes256Gcm> {
+    let mut key = [0u8; 32];
+    let salt = b"client_salt"; // Fixed salt for simplicity
+    pbkdf2::<Hmac<Sha256>>(b"client_key", salt, 10000, &mut key).expect("error deriving key");
+    key.into()
+}
+
+fn encrypt_password(password: &str) -> Result<Vec<u8>, aes_gcm::Error> {
+    let key = derive_key();
+    let cipher = Aes256Gcm::new(&key);
+    let mut nonce_bytes = [0u8; 12];
+    rand::thread_rng().fill(&mut nonce_bytes);
+    let nonce = Nonce::from_slice(&nonce_bytes);
+    let ciphertext = cipher.encrypt(nonce, password.as_bytes())?;
+    let mut result = nonce_bytes.to_vec();
+    result.extend(ciphertext);
+    Ok(result)
+}
+
+fn decrypt_password(encrypted: &[u8]) -> Option<String> {
+    if encrypted.len() < 12 {
+        return None;
+    }
+    let key = derive_key();
+    let cipher = Aes256Gcm::new(&key);
+    let nonce = Nonce::from_slice(&encrypted[..12]);
+    cipher.decrypt(nonce, &encrypted[12..]).ok().and_then(|plaintext| String::from_utf8(plaintext).ok())
+}
diff --git a/src/bin/client/main.rs b/src/bin/client/main.rs
new file mode 100644
index 0000000..ce9c92f
--- /dev/null
+++ b/src/bin/client/main.rs
@@ -0,0 +1,17 @@
+mod repl;
+mod database;
+mod connection;
+mod platform;
+
+use repl::ClientState;
+
+fn main() {
+    #[cfg(windows)]
+    platform::win::enable_vt().unwrap();
+
+    let mut state = ClientState::new();
+    if let Some(host) = state.addr.clone() {
+        state.connect_to(&host);
+    }
+    state.run();
+}
diff --git a/src/bin/client/mod.rs b/src/bin/client/mod.rs
new file mode 100644
index 0000000..938d862
--- /dev/null
+++ b/src/bin/client/mod.rs
@@ -0,0 +1,4 @@
+pub mod database;
+pub mod connection;
+pub mod platform;
+pub mod repl;
diff --git a/src/bin/client/platform.rs b/src/bin/client/platform.rs
new file mode 100644
index 0000000..817c39d
--- /dev/null
+++ b/src/bin/client/platform.rs
@@ -0,0 +1,28 @@
+#[cfg(windows)]
+pub mod win {
+    use std::io;
+    use winapi::um::consoleapi::GetConsoleMode;
+    use winapi::um::consoleapi::SetConsoleMode;
+    use winapi::um::wincon::ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    use winapi::um::wincon::ENABLE_ECHO_INPUT;
+    use winapi::um::winbase::STD_OUTPUT_HANDLE;
+    use winapi::um::processenv::GetStdHandle;
+    use winapi::shared::minwindef::DWORD;
+
+    pub fn enable_vt() -> io::Result<()> {
+        unsafe {
+            let h = GetStdHandle(STD_OUTPUT_HANDLE);
+            if h.is_null() { return Err(io::Error::last_os_error()); }
+
+            let mut mode: DWORD = 0;
+            if GetConsoleMode(h, &mut mode) == 0 {
+                return Err(io::Error::last_os_error());
+            }
+            let new = (mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING) & !ENABLE_ECHO_INPUT;
+            if SetConsoleMode(h, new) == 0 {
+                return Err(io::Error::last_os_error());
+            }
+            Ok(())
+        }
+    }
+}
diff --git a/src/bin/client/repl.rs b/src/bin/client/repl.rs
new file mode 100644
index 0000000..5559cfd
--- /dev/null
+++ b/src/bin/client/repl.rs
@@ -0,0 +1,335 @@
+use std::io::{BufRead, BufReader, Write, stdout};
+use std::net::TcpStream;
+use rusqlite::Connection;
+use std::time::Instant;
+use bcrypt::hash_with_salt;
+
+use crate::connection;
+use crate::database;
+
+const SALT: [u8; 16] = *b"fixedsalt1234567";
+
+fn hash_password(password: &str) -> String {
+    let result = hash_with_salt(password, 10, SALT).unwrap();
+    result.to_string()
+}
+
+use crossterm::{event::{read, Event, KeyCode, KeyModifiers}, terminal::{disable_raw_mode, enable_raw_mode, Clear, ClearType}, cursor::{MoveToColumn, Show}, execute};
+
+macro_rules! println {
+    () => {
+        print!("\r\n")
+    };
+    ($($arg:tt)*) => {
+        print!("\r{}\n", format_args!($($arg)*))
+    };
+}
+
+pub struct ClientState {
+    pub stream: Option<TcpStream>,
+    pub conn: Connection,
+    pub addr: Option<String>,
+    pub default_port: u16,
+    pub history: Vec<String>,
+    pub history_index: usize,
+}
+
+impl ClientState {
+    pub fn new() -> Self {
+        let conn = database::init_db();
+        let default_ip = "127.0.0.1".to_string();
+        let default_port = 11525;
+        let last_host = database::get_last_host(&conn);
+        let default_host = format!("{}:{}", default_ip, default_port);
+        let addr = last_host.or(Some(default_host));
+
+        Self {
+            stream: None,
+            conn,
+            addr,
+            default_port,
+            history: vec![],
+            history_index: 0,
+        }
+    }
+
+    pub fn connect_to(&mut self, addr: &str) {
+        self.addr = Some(addr.to_string());
+        match connection::connect(addr, &self.conn) {
+            Ok(s) => {
+                self.stream = Some(s);
+                database::save_host(&self.conn, addr);
+            }
+            Err(e) => println!("Failed to connect: {}", e),
+        }
+    }
+
+    pub fn run(&mut self) {
+        enable_raw_mode().unwrap();
+        'outer: loop {
+            let mut current_input = String::new();
+            self.history_index = self.history.len();
+            redraw("");
+            loop {
+                match read().unwrap() {
+                    Event::Key(key) => match key.code {
+                        KeyCode::Up => {
+                            if self.history_index > 0 {
+                                self.history_index -= 1;
+                                current_input = self.history[self.history_index].clone();
+                                redraw(&current_input);
+                            }
+                        }
+                        KeyCode::Down => {
+                            if self.history_index < self.history.len() {
+                                self.history_index += 1;
+                                current_input = if self.history_index == self.history.len() { "".to_string() } else { self.history[self.history_index].clone() };
+                                redraw(&current_input);
+                            }
+                        }
+                        KeyCode::Enter => {
+                            let line = current_input.trim().to_string();
+                            if !line.is_empty() {
+                                self.history.push(line.clone());
+                            }
+                            // Process command
+                            let parts: Vec<&str> = line.splitn(2, ' ').collect();
+                            match parts[0] {
+                                "connect" => {
+                                    let addr_str = if parts.len() < 2 {
+                                        if let Some(h) = &self.addr {
+                                            h.clone()
+                                        } else {
+                                            println!("\nNo host specified and no previous connection. Usage: connect <ip>:<port>");
+                                            continue 'outer;
+                                        }
+                                    } else {
+                                        let mut a = parts[1].to_string();
+                                        if !a.contains(':') {
+                                            a = format!("{}:{}", a, self.default_port);
+                                        }
+                                        a
+                                    };
+                                    self.connect_to(&addr_str);
+                                }
+                                "send" => {
+                                    if self.stream.is_none() {
+                                        println!("\nNot connected. Use 'connect <ip>:<port>' first.");
+                                        continue 'outer;
+                                    }
+                                    if parts.len() < 2 {
+                                        println!("\nUsage: send <message>");
+                                        continue 'outer;
+                                    }
+                                    let msg = parts[1];
+                                    let s = self.stream.as_mut().unwrap();
+                                    let writer_stream = s.try_clone().unwrap();
+                                    let mut writer = writer_stream;
+                                    let response_reader_stream = s.try_clone().unwrap();
+                                    let mut response_reader = BufReader::new(response_reader_stream);
+                                    if let Err(_) = writeln!(writer, "{}", msg) {
+                                        self.stream = None;
+                                        println!("\nConnection lost");
+                                        continue 'outer;
+                                    }
+                                    let mut response = String::new();
+                                    if let Err(_) = response_reader.read_line(&mut response) {
+                                        self.stream = None;
+                                        println!("\nConnection lost");
+                                    } else {
+                                        println!("\nEcho: {}", response.trim());
+                                    }
+                                }
+                                "disconnect" => {
+                                    self.stream = None;
+                                    println!("\nDisconnected");
+                                }
+                                "ping" => {
+                                    if self.stream.is_none() {
+                                        println!("\nNot connected. Use 'connect <ip>:<port>' first.");
+                                        continue 'outer;
+                                    }
+                                    let s = self.stream.as_mut().unwrap();
+                                    let writer_stream = s.try_clone().unwrap();
+                                    let mut writer = writer_stream;
+                                    let start = Instant::now();
+                                    let response_reader_stream = s.try_clone().unwrap();
+                                    let mut response_reader = BufReader::new(response_reader_stream);
+                                    if let Err(_) = writeln!(writer, "PING") {
+                                        self.stream = None;
+                                        println!("\nConnection lost");
+                                        continue 'outer;
+                                    }
+                                    let mut response = String::new();
+                                    if let Err(_) = response_reader.read_line(&mut response) {
+                                        self.stream = None;
+                                        println!("\nConnection lost");
+                                    } else {
+                                        if response.trim() == "PING" {
+                                            let elapsed = start.elapsed();
+                                            println!("\nPong ({:?})", elapsed);
+                                        } else {
+                                            self.stream = None;
+                                            println!("\nConnection lost");
+                                        }
+                                    }
+                                }
+                                "register" => {
+                                    if self.stream.is_none() {
+                                        println!("\nNot connected. Use 'connect <ip>:<port>' first.");
+                                        continue 'outer;
+                                    }
+                                    let username = read_line("\nUsername: ");
+                                    if username.is_empty() {
+                                        continue 'outer;
+                                    }
+                                    let password = read_line("Password: ");
+                                    if password.is_empty() {
+                                        continue 'outer;
+                                    }
+                                    let hashed = hash_password(&password);
+                                    let msg = format!("REGISTER {} {}", username, hashed);
+                                    let s = self.stream.as_mut().unwrap();
+                                    let writer_stream = s.try_clone().unwrap();
+                                    let mut writer = writer_stream;
+                                    let response_reader_stream = s.try_clone().unwrap();
+                                    let mut response_reader = BufReader::new(response_reader_stream);
+                                    if let Err(_) = writeln!(writer, "{}", msg) {
+                                        self.stream = None;
+                                        println!("\nConnection lost");
+                                        continue 'outer;
+                                    }
+                                    let mut response = String::new();
+                                    if let Err(_) = response_reader.read_line(&mut response) {
+                                        self.stream = None;
+                                        println!("\nConnection lost");
+                                    } else {
+                                        println!("\n{}", response.trim());
+                                    }
+                                }
+                                "login" => {
+                                    if self.stream.is_none() {
+                                        println!("\nNot connected. Use 'connect <ip>:<port>' first.");
+                                        continue 'outer;
+                                    }
+                                    loop {
+                                        let username = read_line("\nUsername: ");
+                                        if username.is_empty() {
+                                            break;
+                                        }
+                                        let password = read_line("Password: ");
+                                        if password.is_empty() {
+                                            break;
+                                        }
+                                        let hashed = hash_password(&password);
+                                        let msg = format!("AUTH {} {}", username, hashed);
+                                        let s = self.stream.as_mut().unwrap();
+                                        let writer_stream = s.try_clone().unwrap();
+                                        let mut writer = writer_stream;
+                                        let response_reader_stream = s.try_clone().unwrap();
+                                        let mut response_reader = BufReader::new(response_reader_stream);
+                                        if let Err(_) = writeln!(writer, "{}", msg) {
+                                            self.stream = None;
+                                            println!("\nConnection lost");
+                                            break;
+                                        }
+                                        let mut response = String::new();
+                                        if let Err(_) = response_reader.read_line(&mut response) {
+                                            self.stream = None;
+                                            println!("\nConnection lost");
+                                            break;
+                                        } else {
+                                            let resp = response.trim();
+                                            println!("\n{}", resp);
+                                            if resp.starts_with("OK") {
+                                                // Save credentials
+                                                if let Some(addr) = &self.addr {
+                                                    if let Err(e) = database::save_credentials(&self.conn, addr, &username, &password) {
+                                                        println!("Failed to save credentials: {}", e);
+                                                    }
+                                                }
+                                                break;
+                                            } else {
+                                                println!("Authentication failed, try again or press Enter to cancel.");
+                                            }
+                                        }
+                                    }
+                                }
+                                "setcred" => {
+                                    if self.addr.is_none() {
+                                        println!("\nNo host connected. Use 'connect <ip>:<port>' first.");
+                                        continue 'outer;
+                                    }
+                                    let username = read_line("\nUsername: ");
+                                    if username.is_empty() {
+                                        continue 'outer;
+                                    }
+                                    let password = read_line("Password: ");
+                                    if password.is_empty() {
+                                        continue 'outer;
+                                    }
+                                    if let Some(addr) = &self.addr {
+                                        if let Err(e) = database::save_credentials(&self.conn, addr, &username, &password) {
+                                            println!("Failed to save credentials: {}", e);
+                                        } else {
+                                            println!("Credentials saved for {}", addr);
+                                        }
+                                    }
+                                }
+                                "help" => {
+                                    help();
+                                }
+                                "quit" => break 'outer,
+                                _ => help(),
+                            }
+                            break;
+                        }
+                        KeyCode::Backspace => {
+                            if !current_input.is_empty() {
+                                current_input.pop();
+                                redraw(&current_input);
+                            }
+                        }
+                        KeyCode::Char(c) => {
+                            if key.modifiers.contains(KeyModifiers::CONTROL) && c == 'c' {
+                                disable_raw_mode().unwrap();
+                                execute!(stdout(), Show).unwrap();
+                                return;
+                            } else {
+                                current_input.push(c);
+                                redraw(&current_input);
+                            }
+                        }
+                        _ => {}
+                    }
+                    _ => {}
+                }
+            }
+        }
+        disable_raw_mode().unwrap();
+        execute!(stdout(), Show).unwrap();
+    }
+}
+
+fn redraw(current_input: &str) {
+    execute!(stdout(), Clear(ClearType::CurrentLine), MoveToColumn(0)).unwrap();
+    print!("> {}", current_input);
+    stdout().flush().unwrap();
+    execute!(stdout(), MoveToColumn((2 + current_input.len()) as u16)).unwrap();
+}
+
+fn read_line(prompt: &str) -> String {
+    disable_raw_mode().unwrap();
+    execute!(stdout(), Show).unwrap();
+    print!("{}", prompt);
+    stdout().flush().unwrap();
+    let mut input = String::new();
+    std::io::stdin().read_line(&mut input).unwrap();
+    enable_raw_mode().unwrap();
+    execute!(stdout(), crossterm::cursor::Hide).unwrap();
+    input.trim().to_string()
+}
+
+fn help() {
+    println!("Available commands: connect <ip>:<port>, send <message>, disconnect, ping, login, register, setcred, help, quit");
+}
diff --git a/src/bin/server/args.rs b/src/bin/server/args.rs
new file mode 100644
index 0000000..31c0acc
--- /dev/null
+++ b/src/bin/server/args.rs
@@ -0,0 +1,41 @@
+pub struct Args {
+    pub ip: String,
+    pub port: u16,
+}
+
+pub fn parse_args() -> Args {
+    let args: Vec<String> = std::env::args().collect();
+    let mut ip = "127.0.0.1".to_string();
+    let mut port = 11525;
+    let mut i = 1;
+    while i < args.len() {
+        if args[i] == "-p" {
+            if i + 1 < args.len() {
+                port = args[i + 1].parse::<u16>().unwrap_or_else(|_| {
+                    eprintln!("Invalid port number: {}", args[i + 1]);
+                    std::process::exit(1);
+                });
+                i += 2;
+            } else {
+                eprintln!("-p requires a port number");
+                std::process::exit(1);
+            }
+        } else if args[i] == "-i" {
+            if i + 1 < args.len() {
+                ip = args[i + 1].clone();
+                if ip != "127.0.0.1" && ip != "0.0.0.0" {
+                    eprintln!("Invalid IP address: {}. Must be 127.0.0.1 or 0.0.0.0", ip);
+                    std::process::exit(1);
+                }
+                i += 2;
+            } else {
+                eprintln!("-i requires an IP address");
+                std::process::exit(1);
+            }
+        } else {
+            eprintln!("Unknown argument: {}", args[i]);
+            std::process::exit(1);
+        }
+    }
+    Args { ip, port }
+}
diff --git a/src/bin/server/database.rs b/src/bin/server/database.rs
new file mode 100644
index 0000000..9c51997
--- /dev/null
+++ b/src/bin/server/database.rs
@@ -0,0 +1,31 @@
+use rusqlite::Connection;
+
+pub fn init_db() -> Connection {
+    let conn = Connection::open("server.db").unwrap();
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS users (
+            username TEXT PRIMARY KEY,
+            hashed_password TEXT NOT NULL
+        )",
+        [],
+    ).unwrap();
+    conn
+}
+
+pub fn add_user(conn: &Connection, username: &str, hashed_password: &str) -> Result<(), Box<dyn std::error::Error>> {
+    conn.execute(
+        "INSERT INTO users (username, hashed_password) VALUES (?1, ?2)",
+        [username, hashed_password],
+    )?;
+    Ok(())
+}
+
+pub fn get_hashed_password(conn: &Connection, username: &str) -> Option<String> {
+    let mut stmt = conn.prepare("SELECT hashed_password FROM users WHERE username = ?1").unwrap();
+    let mut rows = stmt.query([username]).unwrap();
+    if let Ok(Some(row)) = rows.next() {
+        row.get(0).ok()
+    } else {
+        None
+    }
+}
diff --git a/src/bin/server/handler.rs b/src/bin/server/handler.rs
new file mode 100644
index 0000000..2132d09
--- /dev/null
+++ b/src/bin/server/handler.rs
@@ -0,0 +1,64 @@
+use std::io::{BufRead, BufReader, Write};
+use std::net::TcpStream;
+use std::sync::Mutex;
+use once_cell::sync::Lazy;
+use rusqlite::Connection;
+use crate::database;
+
+static DB_CONN: Lazy<Mutex<Connection>> = Lazy::new(|| Mutex::new(database::init_db()));
+
+pub fn handle_client(stream: TcpStream) {
+    let client_addr = stream.peer_addr().unwrap().to_string();
+    let mut user = "guest".to_string();
+    println!("[{} @ {}] Client connected", user, client_addr);
+    let reader_stream = stream.try_clone().unwrap();
+    let reader = BufReader::new(reader_stream);
+    let mut writer = stream;
+    for line in reader.lines() {
+        let line = line.unwrap();
+        println!("[{} @ {}] Received: {}", user, client_addr, line);
+        let response = process_message(&line, &mut user);
+        writeln!(writer, "{}", response).unwrap();
+    }
+    println!("[{} @ {}] Client disconnected", user, client_addr);
+}
+
+fn process_message(msg: &str, user: &mut String) -> String {
+    let parts: Vec<&str> = msg.splitn(3, ' ').collect();
+    match parts[0] {
+        "REGISTER" => {
+            if parts.len() != 3 {
+                "FAIL Invalid REGISTER format".to_string()
+            } else {
+                let username = parts[1];
+                let hashed_pass = parts[2];
+                let db = DB_CONN.lock().unwrap();
+                match database::add_user(&db, username, hashed_pass) {
+                    Ok(_) => format!("OK Registered {}", username),
+                    Err(_) => "FAIL User already exists".to_string(),
+                }
+            }
+        }
+        "AUTH" => {
+            if parts.len() != 3 {
+                "FAIL Invalid AUTH format".to_string()
+            } else {
+                let username = parts[1];
+                let provided_hash = parts[2];
+                let db = DB_CONN.lock().unwrap();
+                if let Some(stored_hash) = database::get_hashed_password(&db, username) {
+                    if provided_hash == stored_hash {
+                        *user = username.to_string();
+                        format!("OK {}", username)
+                    } else {
+                        "FAIL Invalid credentials".to_string()
+                    }
+                } else {
+                    "FAIL User not found".to_string()
+                }
+            }
+        }
+        "PING" => "PING".to_string(),
+        _ => msg.to_string(), // Echo back for compatibility
+    }
+}
diff --git a/src/bin/server/main.rs b/src/bin/server/main.rs
new file mode 100644
index 0000000..7693069
--- /dev/null
+++ b/src/bin/server/main.rs
@@ -0,0 +1,24 @@
+mod args;
+mod handler;
+mod database;
+
+use std::net::TcpListener;
+use std::thread;
+
+fn main() {
+    let args = args::parse_args();
+    let listener = match TcpListener::bind(format!("{}:{}", args.ip, args.port)) {
+        Ok(l) => l,
+        Err(e) => {
+            eprintln!("Failed to bind to {}:{}: {}", args.ip, args.port, e);
+            std::process::exit(1);
+        }
+    };
+    println!("Server listening on {}", listener.local_addr().unwrap());
+    for stream in listener.incoming() {
+        let stream = stream.unwrap();
+        thread::spawn(move || {
+            handler::handle_client(stream);
+        });
+    }
+}
diff --git a/src/bin/server/mod.rs b/src/bin/server/mod.rs
new file mode 100644
index 0000000..b2d622e
--- /dev/null
+++ b/src/bin/server/mod.rs
@@ -0,0 +1,3 @@
+pub mod args;
+pub mod handler;
+pub mod database;