.

.claude/settings.local.json

@@ -0,0 +1,20 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(npm run test:*)",
+      "Bash(npm test)",
+      "Bash(cargo:*)",
+      "Bash(grep:*)",
+      "Bash(npm test:*)",
+      "Bash(npm run lint)",
+      "Bash(docker build:*)",
+      "Bash(docker image:*)",
+      "Bash(timeout 120 docker buildx build --platform linux/arm64 -t vault-link-arm64-test . --load)",
+      "Bash(docker run:*)",
+      "Bash(./scripts/build-sync-server-binaries.sh:*)",
+      "Bash(npm install:*)"
+    ],
+    "deny": []
+  }
+}

.editorconfig

@@ -0,0 +1,14 @@
+# https://editorconfig.org
+
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+charset = utf-8
+indent_style = space
+indent_size = 4
+
+[*.{yml,yaml}]
+indent_size = 2

.github/dependabot.yml

@@ -0,0 +1,27 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directories: ["/frontend"]
+    schedule:
+      interval: "daily"
+
+  - package-ecosystem: "docker"
+    directories: ["**"]
+    schedule:
+      interval: "daily"
+
+  - package-ecosystem: "cargo"
+    directories: ["**"]
+    schedule:
+      interval: "daily"
+
+  # Disable this for security reasons
+  # - package-ecosystem: "github-actions"
+  #   directories: ["**"]
+  #   schedule:
+  #     interval: "daily"

.github/workflows/check.yml

@@ -0,0 +1,40 @@
+name: Check
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-Dwarnings"
+
+jobs:
+  build:
+    runs-on: self-hosted
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js environment
+        uses: actions/setup-node@v4.2.0
+        with:
+          node-version: "22.x"
+          check-latest: true
+      
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: "1.89.0"
+          components: clippy, rustfmt
+
+      - name: Setup rust
+        run: |
+          cargo install sqlx-cli cargo-machete
+          cd sync-server
+          sqlx database create --database-url sqlite://db.sqlite3
+          sqlx migrate run --source src/app_state/database/migrations --database-url sqlite://db.sqlite3
+
+      - name: Lint & test
+        run: scripts/check.sh

.github/workflows/e2e.yml

@@ -0,0 +1,45 @@
+name: E2E tests
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-Dwarnings"
+
+jobs:
+  build:
+    runs-on: self-hosted
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js environment
+        uses: actions/setup-node@v4.2.0
+        with:
+          node-version: "22.x"
+          check-latest: true
+
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: "1.89.0"
+          components: clippy, rustfmt
+
+      - name: Setup rust
+        run: |
+          cargo install sqlx-cli
+          cd sync-server
+          sqlx database create --database-url sqlite://db.sqlite3
+          sqlx migrate run --source src/app_state/database/migrations --database-url sqlite://db.sqlite3
+
+      - name: E2E tests
+        run: |
+          cd sync-server
+          cargo run config-e2e.yml --color never &
+          cd ..
+
+          scripts/e2e.sh 32

.github/workflows/publish-docker.yml

@@ -0,0 +1,90 @@
+name: Publish server Docker image
+
+on:
+  push:
+    branches: ["main"]
+    tags: ["*"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  # Use docker.io for Docker Hub if empty
+  REGISTRY: ghcr.io
+  # github.repository as <account>/<repo>
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  publish-docker:
+    runs-on: self-hosted
+
+    permissions:
+      contents: read
+      packages: write
+      # This is used to complete the identity challenge
+      # with sigstore/fulcio.
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      # Install the cosign tool
+      # https://github.com/sigstore/cosign-installer
+      - name: Install cosign
+        if: github.ref_type == 'tag'
+        uses: sigstore/cosign-installer@59acb6260d9c0ba8f4a2f9d9b48431a222b68e20 #v3.5.0
+        with:
+          cosign-release: "v2.2.4"
+
+      # Set up BuildKit Docker container builder to be able to build
+      # multi-platform images and export cache
+      # https://github.com/docker/setup-buildx-action
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@f95db51fddba0c2d1ec667646a06c2ce06100226 # v3.0.0
+
+      # Login against a Docker registry
+      # https://github.com/docker/login-action
+      - name: Log into registry ${{ env.REGISTRY }}
+        if: github.ref_type == 'tag'
+        uses: docker/login-action@343f7c4344506bcbf9b4de18042ae17996df046d # v3.0.0
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Extract metadata (tags, labels) for Docker
+      # https://github.com/docker/metadata-action
+      - name: Extract Docker metadata
+        id: meta
+        uses: docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934 # v5.0.0
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      # Build and push Docker image with Buildx
+      # https://github.com/docker/build-push-action
+      - name: Build and push Docker image
+        id: build-and-push
+        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # v5.0.0
+        with:
+          context: sync-server
+          platforms: linux/amd64,linux/arm64
+          push: ${{ github.ref_type == 'tag' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      # Sign the resulting Docker image digest.
+      # This will only write to the public Rekor transparency log when the Docker
+      # repository is public to avoid leaking data. If you would like to publish
+      # transparency data even for private images, pass --force to cosign below.
+      # https://github.com/sigstore/cosign
+      - name: Sign the published Docker image
+        if: ${{ github.ref_type == 'tag' }}
+        env:
+          # https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions#using-an-intermediate-environment-variable
+          TAGS: ${{ steps.meta.outputs.tags }}
+          DIGEST: ${{ steps.build-and-push.outputs.digest }}
+        # This step uses the identity token to provision an ephemeral certificate
+        # against the sigstore community Fulcio instance.
+        run: echo "${TAGS}" | xargs -I {} cosign sign --yes {}@${DIGEST}

.github/workflows/publish-plugin.yml

@@ -0,0 +1,57 @@
+name: Publish Obsidian plugin
+
+on:
+  push:
+    tags: ["*"]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  publish-plugin:
+    runs-on: self-hosted
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js environment
+        uses: actions/setup-node@v4.2.0
+        with:
+          node-version: "22.x"
+          check-latest: true
+
+      - name: Build plugin
+        run: |
+          cd frontend
+          npm ci
+          npm run build
+
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: "1.89.0"
+          components: clippy, rustfmt
+
+      - name: Install cross-compilation tools
+        run: |
+          apt update
+          apt install -y gcc-aarch64-linux-gnu musl-tools gcc-mingw-w64-x86-64
+
+      - name: Build Linux and Windows binaries
+        run: ./scripts/build-sync-server-binaries.sh
+
+      - name: Create release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          tag="${GITHUB_REF#refs/tags/}"
+
+          mkdir -p release
+          cp frontend/obsidian-plugin/dist/* release/
+          cp sync-server/artifacts/sync-server-* release/
+          cd release
+
+          gh release create "$tag" \
+            --title="$tag" \
+            --draft \
+            *

.gitignore

@@ -0,0 +1,21 @@
+# npm
+node_modules
+
+# Exclude macOS Finder (System Explorer) View States
+.DS_Store
+
+
+
+# Frontend build folders
+frontend/*/dist
+
+sync-server/db.sqlite3*
+sync-server/databases
+
+# Rust build folders
+sync-server/target
+sync-server/artifacts
+sync-server/bindings/*.ts
+
+*.log
+*.sqlx

.vscode/settings.json

@@ -0,0 +1,10 @@
+{
+    "jest.jestCommandLine": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" npx jest",
+    "jest.rootPath": "plugin",
+    "files.exclude": {
+        "**/dist": true,
+        "**/node_modules": true,
+        "**/.sqlx": true,
+        "**/target": true,
+    },
+}

CLAUDE.md

@@ -0,0 +1,99 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+VaultLink is a self-hosted Obsidian plugin for real-time collaborative file syncing. The project consists of a Rust-based sync server and a TypeScript frontend with three main components: an Obsidian plugin, a sync client library, and a test client.
+
+## Architecture
+
+### Core Components
+
+- **sync-server/**: Rust-based WebSocket server with SQLite database for document versioning and real-time synchronization
+- **frontend/sync-client/**: TypeScript library providing core sync functionality, WebSocket management, and file operations
+- **frontend/obsidian-plugin/**: Obsidian plugin that integrates the sync client with Obsidian's API
+- **frontend/test-client/**: CLI testing tool for the sync functionality
+
+### Key Technologies
+
+- **Backend**: Rust with Axum framework, SQLite with SQLx, WebSockets for real-time sync
+- **Frontend**: TypeScript, Webpack for bundling, Jest for testing
+- **Sync Algorithm**: Uses reconcile-text library for operational transformation
+
+## Development Commands
+
+### Server Development
+```bash
+cd sync-server
+cargo run config-e2e.yml  # Start development server
+cargo test --verbose      # Run Rust tests
+cargo clippy --all-targets --all-features  # Lint Rust code
+cargo fmt --all -- --check  # Check Rust formatting
+```
+
+### Frontend Development
+```bash
+cd frontend
+npm run dev      # Start development mode (watches sync-client and obsidian-plugin)
+npm run build    # Build all workspaces
+npm run test     # Run all tests
+npm run lint     # Lint and format TypeScript code
+```
+
+### Database Setup (Development)
+```bash
+cd sync-server
+sqlx database create --database-url sqlite://db.sqlite3
+sqlx migrate run --source src/app_state/database/migrations --database-url sqlite://db.sqlite3
+cargo sqlx prepare --workspace
+```
+
+### Scripts
+- `scripts/check.sh`: Full CI check (builds, lints, tests both server and frontend)
+- `scripts/e2e.sh`: End-to-end testing
+- `scripts/clean-up.sh`: Clean logs and database files
+- `scripts/bump-version.sh patch`: Publish new version
+- `scripts/update-api-types.sh`: Update TypeScript bindings from Rust types
+
+## Code Structure
+
+### Workspace Configuration
+The frontend uses npm workspaces with three packages:
+- `sync-client`: Core synchronization logic
+- `obsidian-plugin`: Obsidian-specific integration
+- `test-client`: Testing utilities
+
+### Type Generation
+Rust structs generate TypeScript types via ts-rs crate, stored in `sync-server/bindings/` and used by frontend packages.
+
+### Key Files
+- `sync-server/src/`: Rust server implementation with WebSocket handlers
+- `frontend/sync-client/src/sync-client.ts`: Main sync client entry point
+- `frontend/obsidian-plugin/src/vault-link-plugin.ts`: Main Obsidian plugin class
+- `frontend/sync-client/src/services/sync-service.ts`: Core synchronization logic
+
+## Testing
+
+### Running Tests
+- Server: `cargo test --verbose` 
+- Frontend: `npm run test` (runs Jest across all workspaces)
+- E2E: `scripts/e2e.sh`
+
+### Test Structure
+- Rust: Unit tests alongside source files
+- TypeScript: `.test.ts` files using Jest
+- E2E: Uses test-client to simulate multiple concurrent users
+
+## Code Style
+
+### Rust
+- Uses extensive Clippy lints (see Cargo.toml)
+- Follows pedantic linting rules
+- Forbids unsafe code
+- Uses cargo fmt with default settings
+
+### TypeScript
+- Prettier configuration: 4-space tabs, trailing commas removed, LF line endings
+- ESLint with unused imports plugin
+- Consistent across all three frontend packages

README.md

@@ -0,0 +1,68 @@
+# VaultLink self-hosted Obsidian plugin for file syncing
+
+[![Check](https://github.com/schmelczer/vault-link/actions/workflows/check.yml/badge.svg)](https://github.com/schmelczer/vault-link/actions/workflows/check.yml)
+[![E2E tests](https://github.com/schmelczer/vault-link/actions/workflows/e2e.yml/badge.svg)](https://github.com/schmelczer/vault-link/actions/workflows/e2e.yml)
+[![Publish server Docker image](https://github.com/schmelczer/vault-link/actions/workflows/publish-docker.yml/badge.svg)](https://github.com/schmelczer/vault-link/actions/workflows/publish-docker.yml)
+[![Publish Obsidian plugin](https://github.com/schmelczer/vault-link/actions/workflows/publish-plugin.yml/badge.svg)](https://github.com/schmelczer/vault-link/actions/workflows/publish-plugin.yml)
+
+## Develop
+
+### Install [nvm](https://github.com/nvm-sh/nvm)
+
+-   `curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash`
+-   `nvm install 22`
+-   `nvm use 22`
+-   Optionally set the system-wide default: `nvm alias default 22`
+
+### Set up Rust
+
+-   Install [`rustup`](https://rustup.rs): `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh`
+-   Install [`wasm-pack`](https://rustwasm.github.io/wasm-pack/installer): `curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh`
+-   `cargo install cargo-insta sqlx-cli cargo-edit`
+
+### Install Obsidian on Linux
+
+```sh
+apt install flatpak
+flatpak remote-add --if-not-exists flathub https://dl.flathub.org/repo/flathub.flatpakrepo
+flatpak install flathub md.obsidian.Obsidian
+flatpak run md.obsidian.Obsidian
+```
+
+#### Run in development mode
+
+Start the server:
+
+```sh
+cd sync-server && cargo run config-e2e.yml
+```
+
+```sh
+cd frontend && npm run dev
+```
+
+### Scripts
+
+#### Update HTTP API TS bindings
+
+```sh
+scripts/update-api-types.sh
+```
+
+#### Publish new version
+
+```sh
+scripts/bump-version.sh patch
+```
+
+#### Run E2E tests
+
+```sh
+scripts/e2e.sh
+```
+
+And to clean up the logs & database files, run `scripts/clean-up.sh`
+
+## Projects
+
+-   [Sync server](./sync-server/README.md)

frontend/.claude/settings.local.json

@@ -0,0 +1,13 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm test:*)",
+      "Bash(npm ls:*)",
+      "Bash(find:*)",
+      "Bash(grep -n \"isBinary\" ../node_modules/reconcile-text/dist/reconcile.node.js)",
+      "Read(/home/andras/projects/obsidian-shared-sync/sync-server/**)",
+      "Read(/mnt/wsl/PHYSICALDRIVE1/projects/obsidian-shared-sync/sync-server/**)"
+    ],
+    "deny": []
+  }
+}

frontend/eslint.config.mjs

@@ -0,0 +1,62 @@
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+import unusedImports from "eslint-plugin-unused-imports";
+
+export default [
+	{
+		ignores: [
+			"sync-client/src/services/types.ts",
+			"**/dist/",
+			"**/*.mjs",
+			"**/*.js"
+		]
+	},
+	...tseslint.config({
+		plugins: {
+			"unused-imports": unusedImports
+		},
+		extends: [eslint.configs.recommended, tseslint.configs.all],
+		rules: {
+			"no-unused-vars": "off",
+			"@typescript-eslint/restrict-template-expressions": "off",
+			"@typescript-eslint/no-unused-vars": "off",
+			"@typescript-eslint/no-floating-promises": [
+				"error",
+				{
+					allowForKnownSafeCalls: [
+						{ from: "package", name: ["suite", "test"], package: "node:test" },
+					],
+				},
+			],
+			"@typescript-eslint/parameter-properties": "off",
+			"@typescript-eslint/require-await": "off",
+			"@typescript-eslint/class-methods-use-this": "off",
+			"@typescript-eslint/consistent-return": "off",
+			"@typescript-eslint/no-unsafe-argument": "off",
+			"@typescript-eslint/max-params": [
+				"error",
+				{
+					max: 6
+				}
+			],
+			"@typescript-eslint/no-magic-numbers": "off",
+			"@typescript-eslint/prefer-readonly-parameter-types": "off",
+			"@typescript-eslint/naming-convention": "off",
+			"unused-imports/no-unused-vars": [
+				"warn",
+				{
+					vars: "all",
+					varsIgnorePattern: "^_",
+					args: "after-used",
+					argsIgnorePattern: "^_"
+				}
+			]
+		},
+		languageOptions: {
+			parserOptions: {
+				projectService: true,
+				tsconfigRootDir: import.meta.dirname
+			}
+		}
+	})
+];

frontend/obsidian-plugin/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm run test:*)"
+    ],
+    "deny": []
+  }
+}

frontend/obsidian-plugin/README.md

@@ -0,0 +1,92 @@
+# Obsidian Sample Plugin
+
+This is a sample plugin for Obsidian (https://obsidian.md).
+
+This project uses TypeScript to provide type checking and documentation.
+The repo depends on the latest plugin API (obsidian.d.ts) in TypeScript Definition format, which contains TSDoc comments describing what it does.
+
+**Note:** The Obsidian API is still in early alpha and is subject to change at any time!
+
+This sample plugin demonstrates some of the basic functionality the plugin API can do.
+- Adds a ribbon icon, which shows a Notice when clicked.
+- Adds a command "Open Sample Modal" which opens a Modal.
+- Adds a plugin setting tab to the settings page.
+- Registers a global click event and output 'click' to the console.
+- Registers a global interval which logs 'setInterval' to the console.
+
+## First time developing plugins?
+
+Quick starting guide for new plugin devs:
+
+- Check if [someone already developed a plugin for what you want](https://obsidian.md/plugins)! There might be an existing plugin similar enough that you can partner up with.
+- Make a copy of this repo as a template with the "Use this template" button (login to GitHub if you don't see it).
+- Clone your repo to a local development folder. For convenience, you can place this folder in your `.obsidian/plugins/your-plugin-name` folder.
+- Install NodeJS, then run `npm i` in the command line under your repo folder.
+- Run `npm run dev` to compile your plugin from `main.ts` to `main.js`.
+- Make changes to `main.ts` (or create new `.ts` files). Those changes should be automatically compiled into `main.js`.
+- Reload Obsidian to load the new version of your plugin.
+- Enable plugin in settings window.
+- For updates to the Obsidian API run `npm update` in the command line under your repo folder.
+
+## Releasing new releases
+
+- Update your `manifest.json` with your new version number, such as `1.0.1`, and the minimum Obsidian version required for your latest release.
+- Update your `versions.json` file with `"new-plugin-version": "minimum-obsidian-version"` so older versions of Obsidian can download an older version of your plugin that's compatible.
+- Create new GitHub release using your new version number as the "Tag version". Use the exact version number, don't include a prefix `v`. See here for an example: https://github.com/obsidianmd/obsidian-sample-plugin/releases
+- Upload the files `manifest.json`, `main.js`, `styles.css` as binary attachments. Note: The manifest.json file must be in two places, first the root path of your repository and also in the release.
+- Publish the release.
+
+> You can simplify the version bump process by running `npm version patch`, `npm version minor` or `npm version major` after updating `minAppVersion` manually in `manifest.json`.
+> The command will bump version in `manifest.json` and `package.json`, and add the entry for the new version to `versions.json`
+
+## Adding your plugin to the community plugin list
+
+- Check the [plugin guidelines](https://docs.obsidian.md/Plugins/Releasing/Plugin+guidelines).
+- Publish an initial version.
+- Make sure you have a `README.md` file in the root of your repo.
+- Make a pull request at https://github.com/obsidianmd/obsidian-releases to add your plugin.
+
+## How to use
+
+- Clone this repo.
+- Make sure your NodeJS is at least v16 (`node --version`).
+- `npm i` or `yarn` to install dependencies.
+- `npm run dev` to start compilation in watch mode.
+
+## Manually installing the plugin
+
+- Copy over `main.js`, `styles.css`, `manifest.json` to your vault `VaultFolder/.obsidian/plugins/your-plugin-id/`.
+
+
+## Funding URL
+
+You can include funding URLs where people who use your plugin can financially support it.
+
+The simple way is to set the `fundingUrl` field to your link in your `manifest.json` file:
+
+```json
+{
+    "fundingUrl": "https://buymeacoffee.com"
+}
+```
+
+If you have multiple URLs, you can also do:
+
+```json
+{
+    "fundingUrl": {
+        "Buy Me a Coffee": "https://buymeacoffee.com",
+        "GitHub Sponsor": "https://github.com/sponsors",
+        "Patreon": "https://www.patreon.com/"
+    }
+}
+```
+
+## API Documentation
+
+See https://github.com/obsidianmd/obsidian-api
+
+
+
+
+

frontend/obsidian-plugin/manifest.json

@@ -0,0 +1,10 @@
+{
+	"id": "vault-link",
+	"name": "VaultLink",
+	"version": "0.8.0",
+	"minAppVersion": "0.0.0",
+	"description": "Self-hosted synchronization and collaboration for your Vault.",
+	"author": "Andras Schmelczer",
+	"authorUrl": "https://schmelczer.dev",
+	"isDesktopOnly": false
+}

frontend/obsidian-plugin/package.json

@@ -0,0 +1,40 @@
+{
+    "name": "vault-link-obsidian-plugin",
+    "version": "0.8.0",
+    "description": "This is a sample plugin for Obsidian (https://obsidian.md)",
+    "main": "main.js",
+    "scripts": {
+        "dev": "webpack watch --mode development",
+        "build": "webpack --mode production",
+        "test": "echo \"no tests defined\" && exit 0",
+        "version": "node version-bump.mjs"
+    },
+    "keywords": [],
+    "author": "",
+    "license": "MIT",
+    "devDependencies": {
+        "@plausible-analytics/tracker": "^0.4.0",
+        "@sentry/browser": "^10.8.0",
+        "@types/node": "^22.15.30",
+        "css-loader": "^7.1.2",
+        "date-fns": "^4.1.0",
+        "file-loader": "^6.2.0",
+        "fs-extra": "^11.3.0",
+        "mini-css-extract-plugin": "^2.9.2",
+        "obsidian": "1.8.7",
+        "reconcile-text": "^0.5.0",
+        "resolve-url-loader": "^5.0.0",
+        "sass": "^1.91.0",
+        "sass-loader": "^16.0.5",
+        "sync-client": "file:../sync-client",
+        "terser-webpack-plugin": "^5.3.14",
+        "ts-loader": "^9.5.2",
+        "tslib": "2.8.1",
+        "tsx": "^4.20.5",
+        "typescript": "5.8.3",
+        "url": "^0.11.4",
+        "virtual-scroller": "^1.13.1",
+        "webpack": "^5.99.9",
+        "webpack-cli": "^6.0.1"
+    }
+}

frontend/obsidian-plugin/src/obsidian-file-system.ts

@@ -0,0 +1,174 @@
+import type { Stat, Vault, Workspace } from "obsidian";
+import { MarkdownView, normalizePath } from "obsidian";
+import {
+	utils,
+	type FileSystemOperations,
+	type RelativePath
+} from "sync-client";
+import { getSelectionsFromEditor } from "./views/cursors/get-selections-from-editor";
+import type { TextWithCursors, CursorPosition } from "reconcile-text";
+
+export class ObsidianFileSystemOperations implements FileSystemOperations {
+	public constructor(
+		private readonly vault: Vault,
+		private readonly workspace: Workspace
+	) {}
+
+	public async listAllFiles(): Promise<RelativePath[]> {
+		// Let's implement this by hand because vault.adapter.listAllFiles doesn't always return all files.
+		const allFiles = [];
+		const remainingFolders = [this.vault.getRoot().path];
+
+		// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+		while (true) {
+			const folder = remainingFolders.pop();
+			if (folder == undefined) {
+				break;
+			}
+
+			// This would be a very bad idea to sync as it would mess with
+			// the integrity of the sync database.
+			if (folder.endsWith(".obsidian/plugins/vault-link/data.json")) {
+				continue;
+			}
+
+			const files = await this.vault.adapter.list(normalizePath(folder));
+			allFiles.push(...files.files);
+			remainingFolders.push(...files.folders);
+		}
+
+		return allFiles;
+	}
+
+	public async read(path: RelativePath): Promise<Uint8Array> {
+		path = normalizePath(path);
+		const view = this.workspace.getActiveViewOfType(MarkdownView);
+		if (view?.file?.path === path) {
+			return new TextEncoder().encode(view.editor.getValue());
+		}
+
+		return new Uint8Array(await this.vault.adapter.readBinary(path));
+	}
+
+	public async write(path: RelativePath, content: Uint8Array): Promise<void> {
+		path = normalizePath(path);
+
+		const view = this.workspace.getActiveViewOfType(MarkdownView);
+		if (view?.file?.path === path) {
+			const position = view.editor.getCursor();
+			view.editor.setValue(new TextDecoder().decode(content));
+			view.editor.setCursor(position);
+			return;
+		}
+
+		return this.vault.adapter.writeBinary(
+			path,
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+			content.buffer as ArrayBuffer
+		);
+	}
+
+	public async atomicUpdateText(
+		path: RelativePath,
+		updater: (current: TextWithCursors) => TextWithCursors
+	): Promise<string> {
+		path = normalizePath(path);
+
+		const view = this.workspace.getActiveViewOfType(MarkdownView);
+
+		if (view?.file?.path === path) {
+			const text = view.editor.getValue();
+
+			const cursors: CursorPosition[] = getSelectionsFromEditor(
+				view.editor
+			).flatMap(({ id, start: anchor, end: head }) => [
+				{
+					id: 2 * id,
+					position: anchor
+				},
+				{
+					id: 2 * id + 1,
+					position: head
+				}
+			]);
+
+			const result = updater({
+				text,
+				cursors
+			});
+
+			if (result.text === text) {
+				return text;
+			}
+
+			view.editor.setValue(result.text);
+
+			const selections = [];
+			for (let i = 0; i < result.cursors.length / 2; i++) {
+				const from = result.cursors[2 * i];
+				const to = result.cursors[2 * i + 1];
+				const { line: fromLine, column: fromColumn } =
+					utils.positionToLineAndColumn(result.text, from.position);
+
+				const { line: toLine, column: toColumn } =
+					utils.positionToLineAndColumn(result.text, to.position);
+
+				selections.push({
+					anchor: { line: fromLine, ch: fromColumn },
+					head: { line: toLine, ch: toColumn }
+				});
+			}
+			view.editor.setSelections(selections);
+
+			return result.text;
+		}
+
+		return this.vault.adapter.process(
+			path,
+			(text) =>
+				updater({
+					text,
+					cursors: []
+				}).text
+		);
+	}
+
+	public async getFileSize(path: RelativePath): Promise<number> {
+		return (await this.statFile(path)).size;
+	}
+
+	public async getModificationTime(path: RelativePath): Promise<Date> {
+		return new Date((await this.statFile(path)).mtime);
+	}
+
+	public async exists(path: RelativePath): Promise<boolean> {
+		return this.vault.adapter.exists(normalizePath(path));
+	}
+
+	public async createDirectory(path: RelativePath): Promise<void> {
+		return this.vault.adapter.mkdir(normalizePath(path));
+	}
+
+	public async delete(path: RelativePath): Promise<void> {
+		if (!(await this.vault.adapter.trashSystem(normalizePath(path)))) {
+			return this.vault.adapter.remove(normalizePath(path));
+		}
+	}
+
+	public async rename(
+		oldPath: RelativePath,
+		newPath: RelativePath
+	): Promise<void> {
+		return this.vault.adapter.rename(oldPath, newPath);
+	}
+
+	private async statFile(path: string): Promise<Stat> {
+		const file = await this.vault.adapter.stat(normalizePath(path));
+
+		if (!file) {
+			throw new Error(`File not found: ${path}`);
+		}
+
+		return file;
+	}
+}

frontend/obsidian-plugin/src/vault-link-plugin.ts

@@ -0,0 +1,287 @@
+import type {
+	MarkdownView,
+	Editor,
+	MarkdownFileInfo,
+	TAbstractFile,
+	WorkspaceLeaf
+} from "obsidian";
+import { Platform, Plugin, TFile } from "obsidian";
+import "../manifest.json";
+import { HistoryView } from "./views/history/history-view";
+import { StatusBar } from "./views/status-bar/status-bar";
+import { LogsView } from "./views/logs/logs-view";
+import { StatusDescription } from "./views/status-description/status-description";
+import * as Sentry from "@sentry/browser";
+import { init as plausibleInit } from "@plausible-analytics/tracker";
+import {
+	SyncClient,
+	rateLimit,
+	DEFAULT_SETTINGS,
+	Logger,
+	debugging
+} from "sync-client";
+import { ObsidianFileSystemOperations } from "./obsidian-file-system";
+import { SyncSettingsTab } from "./views/settings/settings-tab";
+import { EditorStatusDisplayManager } from "./views/editor-status-display-manager/editor-status-display-manager";
+import { remoteCursorsTheme } from "./views/cursors/remote-cursor-theme";
+import {
+	remoteCursorsPlugin,
+	RemoteCursorsPluginValue
+} from "./views/cursors/remote-cursors-plugin";
+import { LocalCursorUpdateListener } from "./views/cursors/local-cursor-update-listener";
+import { renderCursorsInFileExplorer } from "./views/cursors/file-explorer";
+
+const MIN_WAIT_BETWEEN_UPDATES_IN_MS = 250;
+
+export default class VaultLinkPlugin extends Plugin {
+	private readonly disposables: (() => unknown)[] = [];
+
+	private settingsTab: SyncSettingsTab | undefined;
+	private client!: SyncClient;
+	private readonly rateLimitedUpdatesPerFile = new Map<
+		string,
+		() => Promise<unknown>
+	>();
+
+	public async onload(): Promise<void> {
+		DEFAULT_SETTINGS.ignorePatterns.push(
+			".obsidian/**",
+			".git/**",
+			".trash/**"
+		);
+
+		const isDebugBuild = process.env.NODE_ENV === "development";
+
+		if (!isDebugBuild) {
+			plausibleInit({
+				domain: "vault-link",
+				endpoint: "https://stats.schmelczer.dev/status",
+				autoCapturePageviews: true,
+				captureOnLocalhost: true,
+				logging: true
+			});
+
+			Sentry.init({
+				dsn: "https://56accd39d92442e788a457a04623cf57@bugs.schmelczer.dev/1",
+				skipBrowserExtensionCheck: false
+			});
+
+			const onError = (event: ErrorEvent): void => {
+				Sentry.captureException(event.error, {
+					extra: {
+						message: event.message,
+						filename: event.filename,
+						lineno: event.lineno,
+						colno: event.colno
+					}
+				});
+			};
+			window.addEventListener("error", onError);
+			this.disposables.push(() => {
+				window.removeEventListener("error", onError);
+			});
+
+			const onUnhandledRejection = (
+				event: PromiseRejectionEvent
+			): void => {
+				Sentry.captureException(event.reason);
+			};
+			window.addEventListener("unhandledrejection", onUnhandledRejection);
+			this.disposables.push(() => {
+				window.removeEventListener(
+					"unhandledrejection",
+					onUnhandledRejection
+				);
+			});
+		}
+
+		const debugOptions = isDebugBuild
+			? {
+					fetch: debugging.slowFetchFactory(1),
+					webSocket: debugging.slowWebSocketFactory(1, new Logger())
+				}
+			: {};
+
+		this.client = await SyncClient.create({
+			fs: new ObsidianFileSystemOperations(
+				this.app.vault,
+				this.app.workspace
+			),
+			persistence: {
+				load: this.loadData.bind(this),
+				save: this.saveData.bind(this)
+			},
+			nativeLineEndings: Platform.isWin ? "\r\n" : "\n",
+			...debugOptions
+		});
+
+		if (isDebugBuild) {
+			debugging.logToConsole(this.client);
+		}
+
+		const statusDescription = new StatusDescription(this.client);
+
+		this.settingsTab = new SyncSettingsTab({
+			app: this.app,
+			plugin: this,
+			syncClient: this.client,
+			statusDescription
+		});
+		this.addSettingTab(this.settingsTab);
+
+		new StatusBar(this, this.client);
+
+		this.registerView(
+			HistoryView.TYPE,
+			(leaf) => new HistoryView(this.client, leaf)
+		);
+
+		this.registerView(
+			LogsView.TYPE,
+			(leaf) => new LogsView(this.client, leaf)
+		);
+
+		this.registerEditorExtension([remoteCursorsTheme, remoteCursorsPlugin]);
+
+		this.client.addRemoteCursorsUpdateListener((cursors) => {
+			RemoteCursorsPluginValue.setCursors(cursors, this.app);
+			renderCursorsInFileExplorer(cursors, this.app);
+		});
+
+		const cursorListener = new LocalCursorUpdateListener(
+			this.client,
+			this.app.workspace
+		);
+		this.disposables.push(() => {
+			cursorListener.dispose();
+		});
+
+		this.app.workspace.updateOptions();
+
+		this.addRibbonIcon(
+			HistoryView.ICON,
+			"Open VaultLink events",
+			async (_: MouseEvent) => this.activateView(HistoryView.TYPE)
+		);
+
+		this.addRibbonIcon(
+			LogsView.ICON,
+			"Open VaultLink logs",
+			async (_: MouseEvent) => this.activateView(LogsView.TYPE)
+		);
+
+		this.app.workspace.onLayoutReady(async () => {
+			this.registerEditorEvents();
+			await this.client.start();
+
+			const editorStatusDisplayManager = new EditorStatusDisplayManager(
+				this,
+				this.app.workspace,
+				this.client
+			);
+			this.disposables.push(() => {
+				editorStatusDisplayManager.stop();
+			});
+		});
+	}
+
+	public onunload(): void {
+		this.client.waitAndStop().catch((err: unknown) => {
+			this.client.logger.error(
+				`Error while stopping the sync client: ${err}`
+			);
+		});
+		this.disposables.forEach((disposable) => {
+			disposable();
+		});
+	}
+
+	public openSettings(): void {
+		// eslint-disable-next-line
+		(this.app as any).setting.open(); // this is undocumented
+		// eslint-disable-next-line
+		(this.app as any).setting.openTab(this.settingsTab); // this is undocumented
+	}
+
+	public closeSettings(): void {
+		// eslint-disable-next-line
+		(this.app as any).setting.close(); // this is undocumented
+	}
+
+	public async activateView(type: string): Promise<void> {
+		const { workspace } = this.app;
+
+		let leaf: WorkspaceLeaf | null = null;
+		const leaves = workspace.getLeavesOfType(type);
+
+		if (leaves.length > 0) {
+			[leaf] = leaves;
+		} else {
+			leaf = workspace.getRightLeaf(false);
+			await leaf?.setViewState({ type: type, active: true });
+		}
+
+		if (leaf) {
+			await workspace.revealLeaf(leaf);
+		}
+	}
+
+	private registerEditorEvents(): void {
+		[
+			this.app.workspace.on(
+				"editor-change",
+				async (
+					_editor: Editor,
+					info: MarkdownView | MarkdownFileInfo
+				) => {
+					const { file } = info;
+					if (file) {
+						await this.rateLimitedUpdate(file.path);
+					}
+				}
+			),
+			this.app.vault.on("create", async (file: TAbstractFile) => {
+				if (file instanceof TFile) {
+					await this.client.syncLocallyCreatedFile(file.path);
+				}
+			}),
+			this.app.vault.on("modify", async (file: TAbstractFile) => {
+				if (file instanceof TFile) {
+					await this.rateLimitedUpdate(file.path);
+				}
+			}),
+			this.app.vault.on("delete", async (file: TAbstractFile) => {
+				await this.client.syncLocallyDeletedFile(file.path);
+			}),
+			this.app.vault.on(
+				"rename",
+				async (file: TAbstractFile, oldPath: string) => {
+					if (file instanceof TFile) {
+						await this.client.syncLocallyUpdatedFile({
+							oldPath,
+							relativePath: file.path
+						});
+					}
+				}
+			)
+		].forEach((event) => {
+			this.registerEvent(event);
+		});
+	}
+
+	private async rateLimitedUpdate(path: string): Promise<void> {
+		if (!this.rateLimitedUpdatesPerFile.has(path)) {
+			this.rateLimitedUpdatesPerFile.set(
+				path,
+				rateLimit(
+					async () =>
+						this.client.syncLocallyUpdatedFile({
+							relativePath: path
+						}),
+					MIN_WAIT_BETWEEN_UPDATES_IN_MS
+				)
+			);
+		}
+		await this.rateLimitedUpdatesPerFile.get(path)?.();
+	}
+}