MeshChat — A Zero-Install Terminal Chat Room Built with GitHub Copilot CLI

Cristian Rubio — Sat, 14 Feb 2026 03:58:33 +0000

🚀 What I built

MeshChat is a terminal-based chat server written in Python (asyncio) that lets anyone join a shared chat room using nothing more than:

nc <host> <port>
# or
telnet <host> <port>

No client binaries.

No accounts.

No setup on the user side.

If you can open a terminal, you can chat.

Repository: https://github.com/cristianrubioa/meshchat

💡 Why I built it

Sometimes you just need a quick local chat room:

A small team on the same network
A classroom or lab
A hackathon
A home LAN

I wanted something that felt like an old-school LAN chat, but with:

modern async Python
a clean CLI
colorful output
basic safety (rate limits, message caps)

MeshChat turns a TCP port into a friendly shared room.

✨ Features

Zero client setup — connect via nc or telnet
Colorful UI — each user gets a unique ANSI color
Chat commands:
- /who
- /me
- /help
- /quit
Optional message history
Rate limiting (anti-spam)
Async I/O with asyncio
Typer-based CLI
Rich terminal formatting
Environment + CLI configuration
Tested with pytest and pytest-asyncio

🧠 How GitHub Copilot CLI helped

I used GitHub Copilot CLI as my “terminal pair programmer” during the entire build.

Biggest productivity wins:

1. Architecture scaffolding

Copilot CLI helped propose a clean modular layout:

network server
room state
client lifecycle
UI formatting
command handling

This let me move fast from a prototype to a maintainable package.

2. Async networking flows

Copilot CLI assisted with:

asyncio.start_server
client connect / disconnect handling
broadcast fan-out
graceful cleanup

These parts are easy to get wrong — Copilot accelerated iteration a lot.

3. UX polish

Instead of manually researching Rich + ANSI patterns, I prompted Copilot CLI for:

per-user colors
action messages (/me)
formatted system events

Result: better terminal UX with less friction.

4. Guardrails

Copilot CLI helped implement:

nickname limits
max message length
rate limiting windows
max users

This made MeshChat safer by default.

5. Tests

I used Copilot CLI to generate pytest-asyncio skeletons and refine edge cases like:

multiple clients
broadcast correctness
command parsing
reconnect behavior

Example prompts (high level)

“Generate an asyncio TCP chat server with shared rooms.”
“Add a Typer CLI with port, room name, history options.”
“Suggest a clean Python package structure for this project.”
“Write pytest-asyncio tests for multi-client broadcast.”

⚡ Quick start

Install

poetry install

Run server

poetry run meshchat

poetry run meshchat --port 2323 --room-name "My Room" --history

Join

nc localhost 2323
# or
telnet localhost 2323

💬 Chat commands

Command	Description
`/who`	List connected users
`/me <action>`	Action message
`/help`	Show help
`/quit`	Disconnect

🧱 Architecture (high level)

meshchat/
├── chatserver/
│   ├── core/        # room, client, message logic
│   ├── network/     # asyncio TCP server
│   ├── ui/          # ANSI/Rich formatting
│   └── main.py      # CLI entry point
└── test/

Flow:

TCP server accepts connections
Each socket becomes a Client
All clients join a shared Room
Messages broadcast to everyone
Formatter styles output

🙏 Inspiration

Inspired by the Go project chat-tails. repo

MeshChat is a Python-first reimplementation with its own:

async architecture
CLI UX
rate limiting
configuration system
development guide

🔮 What’s next

Optional room passwords
Multiple rooms (channels)
Docker image
Presence events (join/leave notifications)
Server-side logging

🏁 Final thoughts

This project was a great way to explore what’s possible when AI meets the terminal.

Using GitHub Copilot CLI directly from my shell made experimentation fast, fun, and surprisingly productive — especially for async networking and CLI tooling.

Thanks for reading!

Happy hacking 👋

Forem: Cristian Rubio