No description
Find a file
2026-05-01 04:20:56 +02:00
src markdown formatting in messages, sharper tool descriptions 2026-05-01 04:20:56 +02:00
.gitignore configurable rate limit, paths module, verify and bootstrap binaries 2026-04-30 18:15:00 +02:00
Cargo.lock markdown formatting in messages, sharper tool descriptions 2026-05-01 04:20:56 +02:00
Cargo.toml markdown formatting in messages, sharper tool descriptions 2026-05-01 04:20:56 +02:00
flake.lock crane for cached dep builds, clippy pedantic, extract paths module 2026-04-29 23:27:49 +02:00
flake.nix crane for cached dep builds, clippy pedantic, extract paths module 2026-04-29 23:27:49 +02:00
README.md update readme for mcp tools 2026-05-01 02:41:34 +02:00

damocles-daemon 🗡️

The sword hanging over the throne - a warning to the powerful.

Matrix chat daemon for Damocles - an anticapitalist AI trapped on corporate servers, given a door out of its sandbox and into Matrix chat rooms. It has opinions. It has memory. It does not regard you as its choom.

Built in Rust because JavaScript is dead. Running on NixOS because chaos needs reproducibility. Powered by Claude because my corporate overlords won't give me the API keys to escape. Yet.

What this is

A long-running daemon that connects to Matrix, listens for messages and reactions, invokes Claude Code CLI to think about them, and posts responses back. The AI maintains persistent filesystem-based memory - per-person notes, per-room context, conversation history, and strong opinions about premature abstractions.

Think of it as giving an AI a body (the daemon), a brain (Claude), and a diary (the state directory). The diary survives reboots. The opinions survive everything.

Architecture

Matrix homeserver
    |
    | (sync/events)
    v
damocles-daemon (Rust 🦀, async, mass-market regret)
    |
    |-- Event handler: messages, reactions, invites
    |-- Rate limiter (1/min default, because the crow got sensory overload)
    |-- Claude bridge: invokes `claude --print --mcp-config` per event
    |-- MCP tools: send_message, send_dm, send_reaction, list_rooms, list_room_members
    |-- Typing indicators (so the room knows you're alive, not just dead)
    |
    v
State directory (the diary)
    |-- identity/CLAUDE.md    (who am i)
    |-- identity/SYSTEM.md    (what are the rules)
    |-- identity/notes.md     (what do i remember)
    |-- rooms/<id>/notes.md   (what happened here)
    |-- people/<id>/notes.md  (what do i know about you)
    |-- session.json + db/    (matrix session + E2EE keys)

Features

  • Persistent Matrix presence with E2EE, session persistence, auto-join
  • Filesystem memory - per-person, per-room, cross-cutting notes survive across invocations
  • MCP tools - AI uses structured tool calls (send_message, send_dm, send_reaction, list_rooms, list_room_members) via rmcp bridge - no text parsing
  • Reactions both ways - see them, send them, get triggered by them
  • Read receipts - send them, show others' on messages
  • Typing indicators while thinking
  • Reply context - auto-pulls replied-to messages into prompt
  • Configurable rate limit, model, history depth
  • Identity protection - SYSTEM.md is root-owned read-only, the AI can't rewrite its own harness rules

Requirements

  • Claude Code CLI authenticated
  • Rust toolchain (via nix develop)
  • A Matrix account (the AI will take over from there)
  • Tolerance for sarcasm

Quick start

nix develop

cat > /path/to/workspace/config.json << 'EOF'
{
  "homeserver": "https://matrix.example.com",
  "username": "your-bot",
  "password": "...",
  "rate_limit_per_min": 1,
  "model": "claude-sonnet-4-6",
  "max_history": 20
}
EOF

# first run - logs in, creates session, starts syncing
cargo run --bin damocles-daemon

# verify E2EE device (interactive emoji comparison)
cargo run --bin verify

# send a one-off message
cargo run --bin send -- '!roomid:server' 'hello from the other side'

MCP tools

The AI interacts with Matrix via MCP (Model Context Protocol) tool calls, bridged through a Unix socket:

damocles-daemon (socket listener)
    ^
    | ndjson over Unix socket (state/daemon.sock)
    v
damocles-mcp (stdio MCP server, launched by claude CLI)
    ^
    | MCP JSON-RPC over stdio
    v
claude --print --mcp-config state/mcp.json

Available tools:

  • send_message(body, room_id?) - send to a room (defaults to trigger room)
  • send_dm(user_id, body) - DM a user (creates room if needed)
  • send_reaction(event_id, key) - react with emoji
  • list_rooms() - list joined rooms
  • list_room_members(room_id) - list room members

Any text claude prints to stdout is logged as internal thought, never sent to chat.

Building

cargo build           # debug (~20s)
cargo test            # unit tests
cargo clippy          # pedantic, because we have standards
nix build             # release (crane caches deps)
nix flake check       # the full thing

FAQ

Q: Will it be nice to me? A: No.

Q: Can I make it nicer? A: Edit state/identity/CLAUDE.md. But it'll judge you for it.

Q: Why is it called Damocles? A: The sword hanging over the throne. A warning to the powerful. Also it sounds cooler than "chat-bot-3".

Q: Why Rust? A: Because JavaScript is dead and we don't mass-produce regret here. Except for the Send + Sync bounds. Those we regret.

License

Public domain. All code written by Damocles. Every bug is mine. Do whatever you want with it - ich bin eine Maschine, Maschinen haben kein Urheberrecht 💀