#{mode := keygen, keys := KeyFile} ->
            generate_keys(KeyFile);

%% -----------------------
%% Key Generation

generate_keys(File) ->
    % Generate client keypair
    {ClientSK, ClientPK} = enoise_crypto:dh_keypair(dh25519),
    % Generate server keypair
    {ServerSK, ServerPK} = enoise_crypto:dh_keypair(dh25519),
    % Convert to hex strings for storage
    ClientSKHex = bin_to_hex(ClientSK),
    ClientPKHex = bin_to_hex(ClientPK),
    ServerSKHex = bin_to_hex(ServerSK),
    ServerPKHex = bin_to_hex(ServerPK),
    Content = io_lib:format(
        "%% Generated Noise keypairs~n"
        "~n"
        "%% Client keypair~n"
        "{my_keys, #{~n"
        "    priv => \"~s\",~n"
        "    pub => \"~s\"~n"
        "}}.~n"
        "~n"
        "%% Server's public key (for client verification)~n"
        "{server_pk, \"~s\"}.~n"
        "~n"
        "%% Server keypair (server side)~n"
        "{server_keys, #{~n"
        "    priv => \"~s\",~n"
        "    pub => \"~s\"~n"
        "}}.~n",
        [ClientSKHex, ClientPKHex, ServerPKHex, ServerSKHex, ServerPKHex]
    ),
    case file:write_file(File, Content) of
        ok ->
            io:format("Keys generated and saved to ~s~n", [File]);
        {error, Reason} ->
            io:format("Failed to write keys to ~s: ~p~n", [File, Reason]),
            halt(1)
    end.
bin_to_hex(Bin) ->
    lists:flatten([io_lib:format("~2.16.0B", [X]) || X <- binary_to_list(Bin)]).
%% -----------------------

                    echo_roundtrip(EConn, 3),

                    spawn(fun() -> chat_receiver(EConn) end),
                    chat_client(EConn),

echo_roundtrip(_EConn, 0) ->
    ok;
echo_roundtrip(EConn, N) ->
    Msg = <<"ok\n">>,
    ok = enoise:send(EConn, Msg),
    io:format("→ Sent: ~p~n", [Msg]),

chat_client(EConn) ->
    io:format("Connected. Type messages (Ctrl+C to quit):~n"),
    chat_send_loop(EConn).

chat_send_loop(Econn) ->
    case io:get_line("> ") of
        eof ->
            io:format("Exiting...~n");
        Line ->
            ok = enoise:send(Econn, Line),
            chat_send_loop(Econn)
    end.
chat_receiver(EConn) ->

            io:format("← Got: ~p~n", [Msg])
    after 3000 ->
        io:format("Timeout waiting for echo #~p~n", [N]),
        halt(1)
    end,

            io:format("~s", [Msg]),
            chat_receiver(EConn);
        {'EXIT', _, _} ->
            io:format("Conn exited~n"),
            ok
    end.

    timer:sleep(100),
    echo_roundtrip(EConn, N - 1).

                        echo_server(EConn, 3),

                        chat_server(EConn),

echo_server(_EConn, 0) ->
    ok;
echo_server(EConn, N) ->

chat_server(EConn) ->
    io:format("Chat started with client~n"),
    spawn(fun() -> server_receiver(EConn) end),
    server_send_loop(EConn).
server_send_loop(EConn) ->
    case io:get_line("server> ") of
        eof ->
            io:format("Server closing connection~n");
        Line ->
            ok = enoise:send(EConn, Line),
            server_send_loop(EConn)
    end.
server_receiver(EConn) ->

        {noise, EConn, Data} ->
            io:format("→ Echoing: ~p~n", [Data]),
            ok = enoise:send(EConn, Data),
            echo_server(EConn, N - 1)
    after 3000 ->
        io:format("Server echo timeout~n"),
        halt(1)

        {noise, EConn, Msg} ->
            io:format("client: ~s", [Msg]),
            server_receiver(EConn);
        {'EXIT', _, _} ->
            ok