JASS by HooMan

Document your experiences in WhatsApp with this OpenClaw-powered bot, connecting context from voice memos to locations from photos.

Built With

Python 3.12
SQLite
YAML configuration
Built-in Python HTTP server (ThreadingHTTPServer) for dashboard + webhook endpoints
WhatsApp Cloud API (Graph API)
OpenClaw
Pillow (EXIF/image handling)
geopy (reverse geocoding)
faster-whisper (speech-to-text)
GitHub Actions + GitHub Repository Secrets (CI/CD and secure runtime configuration)

Inspiration

Out on the open range, travel memories scatter fast: a voice memo in one saddlebag, a photo in another, map pins lost in the dust, and the rest buried in chat threads.

We built JASS to be the town ledger by the campfire, where every moment gets logged before it rides off into the sunset.

What it does

JASS is a messaging-first trail journal deputy for modern travelers.

It can:

Round up travel moments from chat-style inputs.
Turn voice, text, and media context into journal-ready entries.
Store entries in a structured local data model with a simple dashboard for review.
Run a webhook route for WhatsApp-compatible messaging.
Serve a local web dashboard and API to browse entries by user.

The project ships with seeded example data, so the dashboard is ready to ride at first light.

How we built it

JASS is built in Python with a modular architecture under Source/Framework:

core.py is the trail boss for orchestration, webhook handling, dashboard routes, and CLI task wiring.
model.py and related framework modules handle persistence and domain behavior.
YAML config and environment variables define deployment-time settings (tokens, ports, webhook params).

We also built an automated deployment path via workspace scripts and a local-first development workflow:

SQLite schema and seed data for deterministic setup.
CLI commands for initialization, validation, and dashboard startup.
Dashboard + API endpoints for quick functional checks.

Recent reliability work tamed a rough patch in dashboard authentication by enabling trusted local sessions while keeping token checks in place for non-local access.

Challenges we ran into

Authentication friction during local dashboard testing, especially when missing API token headers triggered 401 errors.
Balancing a smooth rider experience with strong security for local development versus external access.
Keeping webhook verification, signature checks, and dashboard auth consistent across config and environment overrides.
Maintaining clarity while evolving a modular codebase with multiple entry points (CLI, web dashboard, webhook).

Accomplishments that we're proud of

Built an end-to-end journal assistant pipeline with local persistence and dashboard visibility.
Implemented secure channel-token API protection and WhatsApp webhook signature verification.
Added local-session-based dashboard auth to end repetitive token entry while preserving external security boundaries.
Created reproducible setup and deploy scripts with seeded data for fast onboarding.
Kept the implementation modular, testable, and configuration-driven.

What we learned

DX (developer experience) matters as much as core features: a small auth UX improvement can dramatically reduce friction.
Security controls should be layered and context-aware (local trusted path vs external token-required path).
Configuration defaults, environment variable precedence, and clear failure messages are critical for fast debugging.
Shipping practical tooling (seed commands, setup scripts, dashboard visibility) accelerates iteration and confidence.

What's next for JASS

Add richer dashboard filtering and timeline views (date range, tags, media type).
Expand automated validation coverage for webhook/auth edge cases.
Improve entry enrichment (location intelligence, better summaries, and smart grouping by trip/day).
Add export options (Markdown/PDF/JSON) for sharing and backup.
Keep hardening production readiness around observability, secrets handling, and deployment automation.
Options for AI tone when generating descriptions

The law of this land is simple: no memory left behind. JASS rides on until every trip has a story worth keeping.