added excalidraw base proj

Author: isaaclins

QUICKSTART.md

@@ -116,7 +116,7 @@ npm run tauri dev
 │   │   │   ├── ConnectionDialog.css
 │   │   │   └── ExcalidrawWrapper.tsx
 │   │   ├── lib/
-│   │   │   ├── api.ts
+│   │   │   ├── api.ts![1760632999038](image/QUICKSTART/1760632999038.png)
 │   │   │   ├── storage.ts
 │   │   │   └── websocket.ts
 │   │   ├── App.tsx

README.md

@@ -7,6 +7,7 @@ A self-hosted, privacy-focused Excalidraw setup with a Tauri desktop application
 - 🖥️ **Desktop App**: Native Tauri application for Windows, macOS, and Linux
 - 🔒 **Privacy First**: All data stored locally by default
 - 🤝 **Optional Collaboration**: Connect to your own server for real-time collaboration
+- 📸 **Room Snapshots**: Save and restore drawing states with thumbnails (manual + auto-save)
 - 💾 **Multiple Storage Options**: SQLite, filesystem, or in-memory storage
 - 🚀 **No Cloud Dependencies**: No Firebase, no external services
 - ⚡ **Fast & Lightweight**: Minimal server with WebSocket support
@@ -139,6 +140,20 @@ cd excalidraw-server
 go build -o excalidraw-server .
 ```
 
+## Room Snapshots
+
+The app includes a powerful snapshot feature for saving and restoring drawing states:
+
+- **📸 Manual Snapshots**: Save snapshots on demand via the menu
+- **⏰ Auto-Save**: Automatic snapshots at configurable intervals (default: 5 min)
+- **🖼️ Thumbnail Previews**: Visual preview of each snapshot
+- **🔧 Configurable**: Per-room settings for max snapshots and auto-save interval
+- **🌐 Smart Storage**: Server-side when connected, local when offline
+
+**Access snapshots**: Menu → 📸 Snapshots
+
+For detailed documentation, see [SNAPSHOTS_FEATURE.md](SNAPSHOTS_FEATURE.md).
+
 ## Architecture
 
 ### Desktop App (Tauri)
@@ -150,16 +165,18 @@ go build -o excalidraw-server .
   - Server connection dialog
   - WebSocket client for collaboration
   - Auto-save functionality
+  - Room snapshots with thumbnails
 
 ### Collaboration Server (Go)
 
 - **WebSocket**: Socket.IO for real-time collaboration
-- **REST API**: Simple save/load endpoints
+- **REST API**: Save/load endpoints + snapshot management
 - **Storage**: Pluggable backends (memory/filesystem/SQLite)
 - **Features**:
   - Room-based collaboration
   - User presence tracking
   - Document persistence
+  - Snapshot storage and retrieval
 
 ## License
 

excalidraw-app/src-tauri/src/commands.rs

@@ -1,4 +1,4 @@
-use crate::db::{Drawing, DB};
+use crate::db::{Drawing, Snapshot, RoomSettings, DB};
 use std::time::{SystemTime, UNIX_EPOCH};
 
 #[tauri::command]
@@ -96,3 +96,175 @@ pub fn delete_drawing(id: String) -> Result<(), String> {
 
     Ok(())
 }
+
+// Snapshot-related commands
+
+#[tauri::command]
+pub fn save_snapshot(
+    room_id: String,
+    name: Option<String>,
+    description: Option<String>,
+    thumbnail: Option<String>,
+    created_by: Option<String>,
+    data: String,
+) -> Result<String, String> {
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs() as i64;
+    
+    let id = uuid::Uuid::new_v4().to_string();
+    
+    let conn = DB.lock().map_err(|e| e.to_string())?;
+    
+    // Get room settings to check max snapshots
+    let settings = get_room_settings_internal(&conn, &room_id)?;
+    
+    // Count existing snapshots
+    let count: i32 = conn
+        .query_row(
+            "SELECT COUNT(*) FROM snapshots WHERE room_id = ?1",
+            rusqlite::params![&room_id],
+            |row| row.get(0),
+        )
+        .map_err(|e| e.to_string())?;
+    
+    // If at limit, delete oldest snapshot
+    if count >= settings.max_snapshots {
+        conn.execute(
+            "DELETE FROM snapshots WHERE id = (SELECT id FROM snapshots WHERE room_id = ?1 ORDER BY created_at ASC LIMIT 1)",
+            rusqlite::params![&room_id],
+        )
+        .map_err(|e| e.to_string())?;
+    }
+    
+    // Insert new snapshot
+    conn.execute(
+        "INSERT INTO snapshots (id, room_id, name, description, thumbnail, created_by, created_at, data) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)",
+        rusqlite::params![&id, &room_id, &name, &description, &thumbnail, &created_by, timestamp, &data],
+    )
+    .map_err(|e| e.to_string())?;
+    
+    Ok(id)
+}
+
+#[tauri::command]
+pub fn list_snapshots(room_id: String) -> Result<Vec<Snapshot>, String> {
+    let conn = DB.lock().map_err(|e| e.to_string())?;
+    
+    let mut stmt = conn
+        .prepare("SELECT id, room_id, name, description, thumbnail, created_by, created_at, '' as data FROM snapshots WHERE room_id = ?1 ORDER BY created_at DESC")
+        .map_err(|e| e.to_string())?;
+    
+    let snapshots = stmt
+        .query_map(rusqlite::params![&room_id], |row| {
+            Ok(Snapshot {
+                id: row.get(0)?,
+                room_id: row.get(1)?,
+                name: row.get(2)?,
+                description: row.get(3)?,
+                thumbnail: row.get(4)?,
+                created_by: row.get(5)?,
+                created_at: row.get(6)?,
+                data: row.get(7)?,
+            })
+        })
+        .map_err(|e| e.to_string())?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| e.to_string())?;
+    
+    Ok(snapshots)
+}
+
+#[tauri::command]
+pub fn load_snapshot(id: String) -> Result<Snapshot, String> {
+    let conn = DB.lock().map_err(|e| e.to_string())?;
+    
+    let snapshot = conn
+        .query_row(
+            "SELECT id, room_id, name, description, thumbnail, created_by, created_at, data FROM snapshots WHERE id = ?1",
+            rusqlite::params![&id],
+            |row| {
+                Ok(Snapshot {
+                    id: row.get(0)?,
+                    room_id: row.get(1)?,
+                    name: row.get(2)?,
+                    description: row.get(3)?,
+                    thumbnail: row.get(4)?,
+                    created_by: row.get(5)?,
+                    created_at: row.get(6)?,
+                    data: row.get(7)?,
+                })
+            },
+        )
+        .map_err(|e| e.to_string())?;
+    
+    Ok(snapshot)
+}
+
+#[tauri::command]
+pub fn delete_snapshot(id: String) -> Result<(), String> {
+    let conn = DB.lock().map_err(|e| e.to_string())?;
+    
+    conn.execute("DELETE FROM snapshots WHERE id = ?1", rusqlite::params![&id])
+        .map_err(|e| e.to_string())?;
+    
+    Ok(())
+}
+
+#[tauri::command]
+pub fn update_snapshot_metadata(id: String, name: String, description: String) -> Result<(), String> {
+    let conn = DB.lock().map_err(|e| e.to_string())?;
+    
+    conn.execute(
+        "UPDATE snapshots SET name = ?1, description = ?2 WHERE id = ?3",
+        rusqlite::params![&name, &description, &id],
+    )
+    .map_err(|e| e.to_string())?;
+    
+    Ok(())
+}
+
+// Room settings commands
+
+fn get_room_settings_internal(conn: &rusqlite::Connection, room_id: &str) -> Result<RoomSettings, String> {
+    conn.query_row(
+        "SELECT room_id, max_snapshots, auto_save_interval FROM room_settings WHERE room_id = ?1",
+        rusqlite::params![room_id],
+        |row| {
+            Ok(RoomSettings {
+                room_id: row.get(0)?,
+                max_snapshots: row.get(1)?,
+                auto_save_interval: row.get(2)?,
+            })
+        },
+    )
+    .or_else(|_| {
+        // Return default settings if not found
+        Ok(RoomSettings {
+            room_id: room_id.to_string(),
+            max_snapshots: 10,
+            auto_save_interval: 300,
+        })
+    })
+}
+
+#[tauri::command]
+pub fn get_room_settings(room_id: String) -> Result<RoomSettings, String> {
+    let conn = DB.lock().map_err(|e| e.to_string())?;
+    get_room_settings_internal(&conn, &room_id)
+}
+
+#[tauri::command]
+pub fn update_room_settings(room_id: String, max_snapshots: i32, auto_save_interval: i32) -> Result<(), String> {
+    let conn = DB.lock().map_err(|e| e.to_string())?;
+    
+    conn.execute(
+        "INSERT INTO room_settings (room_id, max_snapshots, auto_save_interval) VALUES (?1, ?2, ?3) 
+         ON CONFLICT(room_id) DO UPDATE SET max_snapshots = ?2, auto_save_interval = ?3",
+        rusqlite::params![&room_id, max_snapshots, auto_save_interval],
+    )
+    .map_err(|e| e.to_string())?;
+    
+    Ok(())
+}

excalidraw-app/src-tauri/src/db.rs

@@ -13,6 +13,25 @@ pub struct Drawing {
     pub updated_at: i64,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Snapshot {
+    pub id: String,
+    pub room_id: String,
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub thumbnail: Option<String>,
+    pub created_by: Option<String>,
+    pub created_at: i64,
+    pub data: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RoomSettings {
+    pub room_id: String,
+    pub max_snapshots: i32,
+    pub auto_save_interval: i32,
+}
+
 pub static DB: Lazy<Mutex<Connection>> = Lazy::new(|| {
     let conn = Connection::open(get_db_path()).expect("Failed to open database");
     init_db(&conn).expect("Failed to initialize database");
@@ -42,5 +61,29 @@ fn init_db(conn: &Connection) -> Result<()> {
         )",
         [],
     )?;
+    
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS snapshots (
+            id TEXT PRIMARY KEY,
+            room_id TEXT NOT NULL,
+            name TEXT,
+            description TEXT,
+            thumbnail TEXT,
+            created_by TEXT,
+            created_at INTEGER NOT NULL,
+            data TEXT NOT NULL
+        )",
+        [],
+    )?;
+    
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS room_settings (
+            room_id TEXT PRIMARY KEY,
+            max_snapshots INTEGER DEFAULT 10,
+            auto_save_interval INTEGER DEFAULT 300
+        )",
+        [],
+    )?;
+    
     Ok(())
 }

excalidraw-app/src-tauri/src/lib.rs

@@ -14,6 +14,13 @@ pub fn run() {
             commands::load_drawing,
             commands::list_drawings,
             commands::delete_drawing,
+            commands::save_snapshot,
+            commands::list_snapshots,
+            commands::load_snapshot,
+            commands::delete_snapshot,
+            commands::update_snapshot_metadata,
+            commands::get_room_settings,
+            commands::update_room_settings,
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

excalidraw-app/src/App.tsx

@@ -20,8 +20,9 @@ function App() {
       setShowDialog(false);
     }
 
-    // Add keyboard shortcut to open connection dialog (Cmd/Ctrl + K)
+    // Add keyboard shortcuts
     const handleKeyDown = (e: KeyboardEvent) => {
+      // Cmd/Ctrl + K to open connection dialog
       if ((e.metaKey || e.ctrlKey) && e.key === 'k') {
         e.preventDefault();
         setShowDialog(true);