Vault Sync & Publishing Guide

How to sync the IgorSolutions vault via CouchDB and publish it with Quartz. Everything runs on the Igor Private Server. No content filtering — full vault is public. Created: 2026-06-28 · Updated: 2026-06-28

Architecture Overview

┌─────────────────┐                    ┌──────────────────────────┐
│  Your Devices    │     LiveSync       │  Igor Private Server     │
│  (Obsidian)      │ ─────────────────►│  100.125.121.21          │
│                  │     CouchDB        │                          │
│  Edit notes ────►│     :5984          │  ┌────────────────────┐  │
│                  │                    │  │ CouchDB (obsidian) │  │
│                  │                    │  └────────────────────┘  │
│  Vault files ────│─── rsync ────────►│  ┌────────────────────┐  │
│  (/IgorSolutions)│                    │  │ Quartz             │  │
│                  │                    │  │ → builds static    │  │
└─────────────────┘                    │  │   HTML on :8080    │  │
                                       │  └─────────┬──────────┘  │
                                       └────────────┼─────────────┘
                                                    │
                                          VPS nginx proxy
                                                    │
                                       ┌────────────▼─────────────┐
                                       │   VPS (66.179.137.105)   │
                                       │                          │
                                       │ vault.igorai.info        │
                                       │ → proxy to 100.125.121.21│
                                       │   :8080                   │
                                       └──────────────────────────┘

Two independent pipelines on the same server:

LiveSync → CouchDB — keeps vault in sync across your devices (private)
rsync → Quartz → nginx — publishes the vault as a public website

Part 1: CouchDB LiveSync

Status: Already Deployed ✅

CouchDB 3.5.2 is running on the Igor Private Server.

Field	Value
URL (internal)	`http://192.168.1.206:5984`
URL (tailnet)	`http://100.125.121.21:5984`
URL (gated)	`https://igorai.online` (OAuth required)
Database	`obsidian`
Admin user	`admin` (see Private Server note in GeneralOoze vault)
Reader user	`dbreader` (read-only on `obsidian` database)

Setting Up LiveSync in Obsidian

Install the Self-hosted LiveSync plugin in Obsidian (Community Plugins)
Configure:

Remote CouchDB server:
  URI: https://igorai.online
  Username: dbreader
  Password: M69KLsxR1yoZOE6ntQIn
  Database: obsidian

🔐 The URI goes through the OAuth gate.
   You sign in with Google, then LiveSync
   connects to CouchDB behind it.

Enable LiveSync in plugin settings
First sync pushes all vault notes to CouchDB

LiveSync Notes

E2E encryption: Do NOT enable for this vault. Quartz needs to read the raw markdown from the vault directory. LiveSync is purely for multi-device access, not the publishing pipeline.
Sync mode: LiveSync (real-time) works well
Exclude from sync: Only .obsidian/ and .trash/ — everything else is public

Part 2: Vault File Sync (rsync)

Quartz needs actual .md files on disk. LiveSync stores data in CouchDB, not as flat files on the server. So we use rsync to push vault files from minibeaux to the Igor Private Server.

One-Time Setup

# On Igor Private Server
ssh igor@192.168.1.206
mkdir -p ~/vault-content
 
# On minibeaux — test the push
rsync -avz --delete \
  /home/hen/IgorSolutions/ \
  igor@192.168.1.206:/home/igor/vault-content/ \
  --exclude '.obsidian/' \
  --exclude '.trash/'

Deploy Script (on minibeaux)

#!/bin/bash
# ~/GeneralOoze/deploy-vault.sh
 
set -e
 
echo "📤 Syncing vault files to Igor Private Server..."
rsync -avz --delete \
  /home/hen/IgorSolutions/ \
  igor@192.168.1.206:/home/igor/vault-content/ \
  --exclude '.obsidian/' \
  --exclude '.trash/'
 
echo "🔨 Triggering Quartz build..."
ssh igor@192.168.1.206 'cd ~/quartz && npx quartz build'
 
echo "✅ Vault published to https://vault.igorai.info"

This pushes the vault files AND triggers the Quartz build in one command.

Part 3: Quartz on Igor Private Server

What is Quartz?

Quartz 5 transforms your Markdown vault into a beautiful static website with:

Full-text search
Graph view
Backlinks and wikilinks
Callouts, tags, LaTeX
Popover previews
Dark mode

It’s the free, self-hosted equivalent of Obsidian Publish.

Install Prerequisites on Igor Private Server

ssh igor@192.168.1.206
 
# Install Node.js 22.x
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs git
 
# Verify
node --version   # should be v22.x
npm --version    # should be 10.x

Install Quartz

ssh igor@192.168.1.206
 
cd ~
git clone https://github.com/jackyzha0/quartz.git quartz
cd quartz
 
npm install
npx quartz create
# Interactive setup:
#   - Choose a template (start with default)
#   - Base URL: https://vault.igorai.info
#   - Content source: /home/igor/vault-content
#     ^ this is where rsync puts the vault files
 
npx quartz plugin install --from-config
 
# Test build
npx quartz build --serve
# Should be available at http://100.125.121.21:8080

Content Filtering — None Needed

This vault contains no credentials, no internal IPs, no secrets. Everything is public-ready. The only exclusions are structural:

// quartz.config.ts — only exclude non-content folders
ignorePatterns: [
  '**/.obsidian/**',
  '**/.trash/**',
],

No other filtering. The full vault goes public.

Run Quartz as a Persistent Service

Create a systemd service so Quartz stays running:

ssh igor@192.168.1.206
 
sudo cat > /etc/systemd/system/quartz.service << 'EOF'
[Unit]
Description=Quartz static site server
After=network.target
 
[Service]
Type=simple
User=igor
WorkingDirectory=/home/igor/quartz
ExecStart=/usr/bin/npx quartz build --serve --port 8080
Restart=always
RestartSec=5
 
[Install]
WantedBy=multi-user.target
EOF
 
sudo systemctl daemon-reload
sudo systemctl enable --now quartz
sudo systemctl status quartz

Quartz’s built-in --serve mode hosts the static files and watches for changes. When rsync pushes new files, Quartz detects them and rebuilds automatically. No cron needed.

Part 4: VPS Nginx Proxy

The VPS proxies vault.igorai.info to the Quartz server on the Igor Private Server — same pattern as the CouchDB proxy.

DNS

# On minibeaux
ionos-manage add igorai.info vault 66.179.137.105

Nginx Config (on VPS)

ssh root@vps
 
cat > /etc/nginx/sites-available/vault.igorai.info << 'EOF'
server {
    server_name vault.igorai.info;
 
    location / {
        proxy_pass http://100.125.121.21:8080;
        proxy_http_version 1.1;
        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
 
    listen [::]:443 ssl;
    listen 443 ssl;
    ssl_certificate /etc/letsencrypt/live/vault.igorai.info/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/vault.igorai.info/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
}
server {
    if ($host = vault.igorai.info) { return 301 https://$host$request_uri; }
    server_name vault.igorai.info;
    listen 80;
    listen [::]:80;
    return 404;
}
EOF
 
ln -s /etc/nginx/sites-available/vault.igorai.info /etc/nginx/sites-enabled/
certbot --nginx -d vault.igorai.info
systemctl reload nginx

Public or Gated?

Current plan: public. The vault has no secrets, and a public site is more useful for the business. If you later want it behind OAuth, swap the proxy_pass to go through port 4181 instead.

Part 5: Daily Workflow

1. Edit notes in Obsidian on minibeaux
2. LiveSync syncs changes to CouchDB (automatic, multi-device)
3. When ready to publish:
   ~/GeneralOoze/deploy-vault.sh
4. rsync pushes vault files to Igor Private Server
5. Quartz detects changes, rebuilds automatically
6. Site updates at https://vault.igorai.info (near-instant)

Or set up a cron job for hands-off publishing:

# On minibeaux — crontab -e
# Push vault and trigger Quartz rebuild every hour
0 * * * * ~/GeneralOoze/deploy-vault.sh >> ~/GeneralOoze/deploy-vault.log 2>&1

Quick Reference

Step	Command
Sync vault (multi-device)	Automatic via LiveSync → CouchDB
Push vault to server	`~/GeneralOoze/deploy-vault.sh`
Check Quartz service	`ssh igor@192.168.1.206 'systemctl status quartz'`
View Quartz logs	`ssh igor@192.168.1.206 'journalctl -u quartz -f'`
Manual Quartz rebuild	`ssh igor@192.168.1.206 'cd ~/quartz && npx quartz build'`
Check CouchDB	`curl http://192.168.1.206:5984/obsidian`
Live site	https://vault.igorai.info

To-Do

Install Node.js + git on Igor Private Server
Clone and configure Quartz on Igor Private Server
Create ~/vault-content/ directory on Igor Private Server
Create /etc/systemd/system/quartz.service
Create vault.igorai.info DNS record (ionos-manage add igorai.info vault 66.179.137.105)
Create VPS nginx config for vault.igorai.info
Get SSL cert for vault.igorai.info
Create ~/GeneralOoze/deploy-vault.sh on minibeaux
Test full pipeline: edit → deploy → view

Quartz 5

Explorer

Sync and Publishing