Obsidian

Promptfree, for everyone, and the only version there is

Copy the prompt for Claude CodeCopy the prompt for CodexCopy the prompt for Cursor

Copy

Build me the sync I need instead of paying for Obsidian Sync: my vault, encrypted, on every device, with version history.

Read this first: Obsidian itself is free for personal use and your notes are already plain Markdown files on your own disk — only sync and publish are paid, and Sync is genuinely good value for what it does. The free answer that works today is Syncthing between your own machines: no server, no accounts, and it handles a vault well. Build this when you want history on the server, sharing between people, or a sync service that is yours.

STACK
- Node 20+ with Fastify
- SQLite through better-sqlite3, WAL mode
- Local disk or an S3-compatible target for encrypted blobs
- A plugin for the app, since that is how it connects
- Caddy in front

THE PRINCIPLE
- The vault is a folder of Markdown files on disk and stays that way. This service holds encrypted copies for transport and history, and never becomes the source of truth
- If this server disappears tomorrow, every note is still on every device, readable in any editor. Nothing built here may compromise that

THE DATA MODEL
- vaults: id, user_id, name, quota_bytes, used_bytes, created_at
- files: id, vault_id, path_hash, path_encrypted, sha256, bytes, blob_path, version, mtime_client, updated_at, deleted_at
- versions: id, file_id, sha256, blob_path, bytes, version, at — history lives here, and it is the thing you are actually buying
- deltas: id, vault_id, file_id, kind, at — ordered by a server counter, never by a device clock
- devices: id, vault_id, name, platform, public_key, last_seen_at, revoked_at
- shares: id, vault_id, path_hash, recipient_id, permission, key_wrapped, accepted_at
- Even the path is encrypted. A file called `divorce-notes.md` tells the server something it has no business knowing, so paths are stored as a hash for lookup and as ciphertext for display

ENCRYPTION
- The client encrypts content and paths with a key derived from a passphrase using argon2id at parameters that cost about a second on the slowest device
- The server stores ciphertext, byte counts and hashes. It can decrypt nothing, and no feature is ever added that would require it to
- Authenticated encryption with a fresh nonce per version; a tampered blob fails to decrypt rather than decrypting to rubbish
- The passphrase is separate from the account password, and losing it means losing the remote copy. Say that at setup and make the user acknowledge it
- Key rotation: re-encrypt under a new passphrase atomically, keeping the old blobs until every device has confirmed

SYNC
- The client asks for changes since a cursor and gets an ordered feed
- Per-file, by content hash: an unchanged file is never transferred
- Chunked and resumable for large attachments, with server-side verification of the assembled hash
- Quotas enforced on write with a clear error
- The client watches the filesystem and debounces — a vault under an editor produces a burst of writes for one saved note

CONFLICTS
- Optimistic concurrency with a version per file. A write against a stale version is rejected
- The client writes a conflict copy beside the original, named clearly, and tells the user. The server never merges and never picks a winner
- A sync that silently chooses will eventually eat a paragraph and you will notice a month later. This is the single most important behaviour in the product

VERSION HISTORY, WHICH IS THE PAID FEATURE
- Every version kept, thinned over time: all versions for a day, hourly for a week, daily for a month, then monthly
- Restore any version to any device, which writes a new version rather than rewriting history
- A diff between versions, computed on the client because the server cannot read them
- Deleted files kept for a stated period and restorable. Deleting a note by accident is the most common disaster in a vault, and this is the fix

SHARING
- A folder shared with another account, with the key wrapped for the recipient by the sender's client. The server relays a wrapped key and never holds a readable one
- Permissions read or write, revocable, with revocation forcing a re-key

THE PLUGIN
- Settings for the server, the vault and the passphrase
- Status: what is syncing, what failed, when the last successful sync was. A sync you cannot verify is a sync you do not trust
- Conflicts surfaced in the app, not left as mysterious files
- Selective sync so a large attachments folder can be excluded on a phone

OPERATIONS
- .env: DATABASE_PATH, STORAGE_PATH, BASE_URL, SESSION_SECRET, MAX_FILE_BYTES, S3_*
- Migrations on boot, each once
- Nightly backup of ciphertext, safe to store anywhere, with a tested restore
- A careful orphan sweeper; an over-eager one deleting a live blob is the worst bug this service can have
- Health endpoint

WHAT MATTERS MOST
Conflict copies and version history. Build those two first, then edit the same note on two devices while both are offline and bring them back together. And be honest: if you only need two machines in sync, Syncthing does it today for nothing.

Give me the repository, the plugin, migrations, .env.example, and a README that opens with the Syncthing alternative and the passphrase warning.