DEV Community

Cover image for MeshChat — A Zero-Install Terminal Chat Room Built with GitHub Copilot CLI
Cristian Rubio
Cristian Rubio

Posted on

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

#devchallenge #githubchallenge #cli #githubcopilot

GitHub Copilot CLI Challenge Submission

🚀 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>
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Run server 

poetry run meshchat
Enter fullscreen mode Exit fullscreen mode

or

poetry run meshchat --port 2323 --room-name "My Room" --history
Enter fullscreen mode Exit fullscreen mode

Join 

nc localhost 2323
# or
telnet localhost 2323
Enter fullscreen mode Exit fullscreen mode

💬 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/
Enter fullscreen mode Exit fullscreen mode

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 👋

Top comments (0)