Multi-device sync: Connect desktop and laptop instances to shared Google Drive/Dropbox location

[hyper-charlie]

Use Case

Users with multiple devices (e.g., desktop and laptop) need to access the same meeting notes and transcripts across both machines without manual file transfers.

Desired Behavior

• Connect multiple Hyprnote instances to a single Google Drive or Dropbox location
• All notes created on one device automatically appear on the other
• Seamless synchronization without manual intervention

Current Workaround

Currently, there's no native way to sync notes between devices, forcing users to manually export/import or maintain separate note collections on each machine.

Benefits

• Improved productivity for users who work across multiple devices
• Better continuity across work environments (office desktop, mobile laptop, etc.)
• Competitive feature matching other note-taking apps with cloud sync

Implementation Considerations

• Support for major cloud storage providers (Google Drive, Dropbox)
• Real-time or periodic sync depending on architecture
• Conflict resolution for notes edited on multiple devices simultaneously

[devin-ai-integration]

Codebase Context for Multi-Device Sync

I explored the codebase to understand the current storage/sync architecture and what building blocks already exist. Here's a summary of the relevant components and considerations.

Current Architecture: Filesystem as Data Layer

Char uses a local-first, filesystem-based storage model. There is no database — all data (sessions, transcripts, notes, contacts, settings) lives as plain files on disk (Markdown with YAML frontmatter + JSON files). The data flow is:

UI → TinyBase (in-memory reactive store) → Persister → fs-sync plugin → disk
disk → file watcher (notify plugin) → Persister → TinyBase → UI

This is documented in apps/web/content/docs/guides/0.data.mdx.

Key Files & Components

Storage & Vault System:

• crates/storage/src/vault/path.rs — vault path resolution, customization, and validation logic
• plugins/settings/src/ext.rs — vault_base(), set_vault_base(), move_vault(), copy_vault() operations
• apps/desktop/src/settings/general/storage/index.tsx — Storage settings UI, including custom path selection + Obsidian vault detection

Filesystem Sync Plugin (tauri-plugin-fs-sync):

• plugins/fs-sync/ — Rust plugin for all file I/O (batch reads/writes, folder management, session discovery, attachments, audio)
• crates/fs-sync-core/ — Core library with session content loading, folder operations, audio handling, frontmatter parsing

File Watcher (tauri-plugin-notify):

• plugins/notify/src/ext.rs — Watches the vault directory recursively for external changes using OS-level file events (via the notify crate) with 900ms debouncing
• plugins/notify/src/events.rs — Emits FileChanged events when files change externally
• Has an own_writes mechanism to distinguish app-written changes from external ones

Persister Layer:

• apps/desktop/src/store/tinybase/persister/ — Three persister factories: JSON file, Markdown directory, and multi-table directory
• Handles bidirectional sync between TinyBase and filesystem, with polling fallback (3s for JSON, 30s for directories)

Google Drive (already exists!):

• crates/google-drive/ — Full Google Drive API client (GoogleDriveClient) with list, get, download, upload, create folder, delete, update metadata operations
• crates/api-storage/src/routes/storage.rs — Backend API routes wrapping Google Drive client
• crates/api-nango/src/integrations.rs — Nango integration IDs for google-drive, google-calendar, outlook-calendar

Recent Related Changes

• Custom vault location (v1.0.11, March 2026) — Users can now set any folder as their vault location, including a synced drive or Dropbox folder. This was explicitly designed for this use case: "a Dropbox folder, or a company-managed directory" (changelog)
• 417eb13e4 — "support vault customization"
• a5d4d70a6 — "Extract crates/storage from plugins/settings"
• ba2869a8b — "extract fs-sync-core from fs-sync plugin"

What Already Works (Partial Solution)

The custom vault location feature already enables a basic form of multi-device sync:

1. Point the vault path to a Google Drive / Dropbox / iCloud folder
2. The cloud provider syncs the files between devices
3. The notify plugin watches for external file changes and reloads data into TinyBase

This is a "passive sync" approach — it relies entirely on the cloud provider's native desktop sync client (Google Drive for Desktop, Dropbox, etc.) handling file sync.

Gaps & Considerations for Native Sync

If the goal is to go beyond "point vault at a synced folder" toward native cloud sync:

1. Conflict resolution — The current file watcher does simple last-write-wins. Simultaneous edits from two devices would overwrite each other. The orphan cleanup safeguard (skip if >50% items disappear) provides some protection against data loss, but isn't a conflict resolution strategy.

2. Google Drive API plumbing exists — crates/google-drive/ and crates/api-storage/ already have full CRUD operations. These route through Nango for OAuth. This could be extended to build direct file-level sync without requiring a desktop sync client.

3. No Dropbox crate exists — Only Google Drive has an API client. Dropbox would need a new crate.

4. Audio files are large — Sessions include .mp3 recordings. Syncing these over cloud APIs would require chunked uploads and careful bandwidth management.

5. Roadmap alignment — The "Memory" roadmap item mentions "Log interactions from multiple devices and your memory becomes ubiquitous" as a high-priority feature targeted for June 2026, with related issues Memory & learning #3474, voiceprint #2266, Speaker identification #956.

Summary

The simplest path is already available: users can set their vault location to a cloud-synced folder via Settings > General > Storage. For native sync, the Google Drive API client and Nango auth integration are already built — the main engineering work would be building a sync engine with conflict resolution on top of the existing fs-sync and notify infrastructure.