Forem: KUSHAL BARAL

Haul :) a tiny file organizer daemon for Linux

KUSHAL BARAL — Sat, 25 Apr 2026 11:21:47 +0000

I hate messy Downloads folders. You know the feeling:

report.pdf
report(1).pdf
report(2).pdf
screenshot.png
screenshot(1).png
screenshot(2).png
video_final.mp4
video_final_FINAL.mp4
notes.docx
notes_copy.docx
notes_copy_FINAL(1).docx

At some point you just stop caring and let it rot.

Cron jobs felt overkill — why poll every minute just to watch an empty folder? So I built haul. Drop a file in a watched folder, it moves it to the right place. That's it.

The trick — zero CPU when idle

haul uses inotify, a filesystem event API built into the Linux kernel. Instead of running a loop, it just waits for the kernel to say "hey, a file arrived" — sorts it — then exits. systemd restarts it immediately for the next file.

No polling. No persistent process. Nothing running between events.

file lands
    ↓
kernel fires inotify
    ↓
haul wakes up
    ↓
file sorted → ~/Data/subfolder
    ↓
haul exits
    ↓
systemd restarts it
    ↓
(waiting for next file...)

Install

sudo apt install inotify-tools -y
curl -fsSL https://raw.githubusercontent.com/kushal1o1/haul/main/install.sh | bash

Usage

haul install      set up and start
haul sweep        sort files already sitting in watched folders
haul start/stop   manage the service
haul logs         tail the live log
haul uninstall    remove haul (your ~/Data/ is untouched)

What it sorts

Folder	Extensions
PDFs	`.pdf`
Images	`.jpg` `.jpeg` `.png` `.gif` `.webp` `.svg`
Videos	`.mp4` `.mkv` `.avi` `.mov` `.webm`
Audio	`.mp3` `.flac` `.wav` `.ogg` `.m4a`
Code	`.py` `.js` `.ts` `.sh` `.json` `.yaml` `.sql`
Zips	`.zip` `.tar.gz` `.rar` `.7z` `.deb`
WordFiles	`.doc` `.docx` `.odt`
Excel	`.xlsx` `.xls` `.csv`
Others	everything else

Screenshots are detected by source folder, not filename — set SCREENSHOTS to wherever your tool saves them.

Fully configurable

Everything — watched folders, destination, subfolder names, extension rules — is just bash variables at the top of ~/.local/bin/haul. Open it in any editor and change what you want.

DATA="$HOME/Files"          # change destination
DOWNLOADS="$HOME/Desktop"   # change watched folder

After editing: haul restart

Duplicate handling

Same file arrives again → deleted silently
Same name, different content → renamed with a timestamp before moving

Logs

[2024-01-15 14:30:22] MOVED report.pdf → ~/Data/PDFs/
[2024-01-15 14:31:45] DUPLICATE (identical) skipped: report.pdf
[2024-01-15 14:32:10] CONFLICT renamed: notes_20240115_143210.md

Requirements: Linux with systemd, bash 4+, inotify-tools. Tested on Ubuntu 22.04 / 24.04.

Source: github.com/kushal1o1/haul — MIT licensed.

If you've been living with a messy Downloads folder, give haul sweep a try first — it sorts whatever's already there without touching the daemon.

Real MCP has a lot going on - but the core idea is this simple

KUSHAL BARAL — Tue, 21 Apr 2026 17:18:37 +0000

MCP (Model Context Protocol) is everywhere right now. Claude uses it, Cursor uses it, a ton of AI tooling is being built on top of it. There's an official SDK, servers, transports, capabilities negotiation... it can feel like a lot.

But when I actually dug into what MCP is doing at its core, I realized — it's just structured JSON going back and forth. That's the whole idea. So I built a minimal version from raw Python, no libraries, to make sure I actually understood it before touching the real thing.

What MCP actually is

Strip away the SDK and the spec details — here's the mental model:

a server exposes tools (functions an AI can call)
a client discovers those tools and calls them by name
everything is JSON, every message has a predictable shape

The real MCP spec adds things like capability negotiation, resource types, prompt templates, SSE transport, and more. But that core loop — client asks, server responds with a tool result — is the same.

Think of it like HTTP but designed specifically for AI agents calling tools. The protocol exists so any agent can talk to any server without needing custom glue code.

What I built to understand it

Two versions, zero external dependencies — just Python stdlib:

Basic version — the absolute minimum:

client sends a JSON request
server reads it from stdin
server runs a tool
server replies with JSON on stdout

Richer version — closer to real MCP, adds a JSON-RPC style flow:

initialize — handshake, server returns its name and version
tools/list — client asks what tools exist
tools/call — client calls a tool by name with arguments

That three-step flow is basically what happens every time an AI agent connects to a real MCP server.

How a protocol works (the bit no one explains)

Two processes agree on a message format, then just talk. That's it. In this case:

the server sits there reading stdin line by line
the client writes one JSON object per line, reads one JSON response back
no sockets, no framework — just text in an agreed shape

Real MCP uses stdio transport for local servers and SSE for remote ones. Same idea, just fancier plumbing.

Try it

python3 basic-mcp-server.py

Type a raw request:

{"tool": "say_hello", "arguments": {"name": "bro"}}

Get back:

{"result": "Hello bro"}

No library. No magic. Just Python reading and writing JSON — same as what the real SDK wraps.

Full code here → https://github.com/kushal1o1/Mcp-basics

Now I want to build an actual MCP module on top of this foundation — something useful, something real. A devtool? A workflow helper for AI agents?

Drop your idea in the comments — what MCP module should I build next? I'll pick the most interesting one and document the whole thing.