+
+
+
+---
+
+## Key Features
+
+- **Unlimited clipboard history** — every copy is captured and stored locally with full-text search (FTS5)
+- **AES-256-GCM encryption** — optional master password locks your vault; Argon2id key derivation
+- **Auto-lock** — vault locks automatically after a configurable inactivity timeout
+- **Tags** — organize items with color-coded tags; filter by tag from the sidebar
+- **Pin & favorite** — surface important items instantly
+- **WASM plugins** — extend clipboard processing with sandboxed WebAssembly modules
+- **Cross-device sync** — optional HTTP sync to a self-hosted relay server
+- **Global shortcuts** — `⌘⇧V` to show/hide, `⌘⇧C` to quick-paste the most recent item
+- **System tray** — runs silently in the background
+- **CLI** — full `openpaste` command-line interface for scripting and automation
+
+---
+
+## Installation
+
+Download the correct package for your system from the latest [GitHub Releases](https://github.com/YOUR_USERNAME/openpaste/releases).
+
+### 🖥️ macOS
+
+1. **Download**:
+ - **Apple Silicon (M1/M2/M3/M4):** `OpenPaste_x.x.x_aarch64.dmg`
+ - **Intel Mac:** `OpenPaste_x.x.x_x64.dmg`
+
+2. **Install:** Double-click the `.dmg` and drag **OpenPaste** to your Applications folder.
+
+3. **First launch — bypass Gatekeeper** (unsigned build):
+ - Right-click `OpenPaste.app` → **Open** → **Open** in the warning dialog.
+ - Or run in Terminal:
+ ```bash
+ xattr -cr /Applications/OpenPaste.app
+ ```
+
+### 🪟 Windows
+
+1. **Download:** `OpenPaste_x.x.x_x64-setup.exe` (installer) or `OpenPaste_x.x.x_x64.msi`
+2. **Install:** Run the installer and follow the setup wizard.
+3. **SmartScreen:** Click **More info → Run anyway** if Windows flags the unsigned build.
+
+### 🐧 Linux
+
+1. **Download:** `OpenPaste_x.x.x_amd64.deb` (Debian/Ubuntu) or `OpenPaste_x.x.x_amd64.AppImage` (universal)
+
+2. **Install `.deb`:**
+ ```bash
+ sudo dpkg -i OpenPaste_*.deb
+ ```
+
+3. **Run `.AppImage`:**
+ ```bash
+ chmod +x OpenPaste_*.AppImage
+ ./OpenPaste_*.AppImage
+ ```
+
+---
+
+## CLI
+
+The `openpaste` CLI talks to the running daemon over a Unix socket:
+
+```bash
+openpaste list # Show clipboard history
+openpaste search "query" # Full-text search
+openpaste copy
- {
+ searchInputRef.current?.focus()
+ updateActivity()
+ }} />
+ updateActivity()} />
+ {
+ setShowPlugins(true)
+ loadPlugins()
+ updateActivity()
+ }}>
+ {
+ setShowSettings(true)
+ updateActivity()
+ }} />
+
- {/* Search Section */}
-
-
{/* end Search + List + Tag Sidebar */}
{/* Bottom Status Bar */}
-
+ )}
- {/* Clipboard List */}
-
+
+ {/* Tag Sidebar */}
+ {allTags.length > 0 && (
-
- ⌘K
+
-
+ Tags
+
+ setActiveTagFilter(null)}
+ style={{
+ padding: '6px 10px',
+ borderRadius: '6px',
+ fontSize: '13px',
+ fontWeight: '500',
+ cursor: 'pointer',
+ backgroundColor: activeTagFilter === null ? '#262B31' : 'transparent',
+ color: activeTagFilter === null ? '#F3F5F8' : '#A7B0BC',
+ }}
+ >
+ All items
+
+ {allTags.map(tag => (
+
+
+ ))}
setActiveTagFilter(activeTagFilter === tag.id ? null : tag.id)}
+ style={{
+ flex: 1,
+ padding: '6px 10px',
+ borderRadius: '6px',
+ fontSize: '13px',
+ cursor: 'pointer',
+ display: 'flex',
+ alignItems: 'center',
+ gap: '6px',
+ color: activeTagFilter === tag.id ? '#F3F5F8' : '#A7B0BC',
+ }}
+ >
+
+
+ {tag.name}
+
+
+
+
+ {/* Right pane: Search + List */}
+
{/* end right pane */}
+
+
+ {/* Search Section */}
+
{/* end Clipboard List */}
+
+
+
+
+ {/* Clipboard List */}
+
+
+
+ ⌘K
+
+
{loading && (
+
Loading clipboard history...
@@ -358,49 +964,69 @@ function App() {
{!loading && !error && (
{
e.stopPropagation()
- copyToClipboard(item.content)
+ if (item.content_type !== 'encrypted') {
+ copyToClipboard(item.content)
+ updateActivity()
+ }
}}
/>
{
e.stopPropagation()
togglePin(item)
+ updateActivity()
}}
/>
{
e.stopPropagation()
toggleFavorite(item)
+ updateActivity()
}}
/>
{
e.stopPropagation()
deleteItem(item.id)
+ updateActivity()
}}
/>
@@ -517,41 +1200,646 @@ function App() {
)}
)}
-
- {filteredItems.map((item) => {
+ {filteredItems.map((item, index) => {
const IconComponent = getIconForType(item.content_type)
+ const isSelected = index === selectedIndex
return (
+ ) : (
+
{/* Vertical Separator */}
@@ -468,11 +1145,14 @@ function App() {
{
+ setSelectedIndex(index)
e.currentTarget.style.transform = 'translateY(-1px)'
e.currentTarget.style.borderColor = '#5A6471'
e.currentTarget.style.boxShadow = '0 6px 12px rgba(0,0,0,0.28)'
}}
onMouseLeave={(e) => {
+ setSelectedIndex(-1)
e.currentTarget.style.transform = 'translateY(0)'
e.currentTarget.style.borderColor = '#343A44'
e.currentTarget.style.boxShadow = '0 4px 8px rgba(0,0,0,0.22)'
}}
- onClick={() => setSelectedItem(item)}
+ onClick={() => {
+ if (item.content_type !== 'encrypted') {
+ setSelectedItem(item)
+ }
+ updateActivity()
+ }}
+ onContextMenu={(e) => {
+ e.preventDefault()
+ e.stopPropagation()
+ setContextMenu({ x: e.clientX, y: e.clientY, item })
+ }}
>
{/* Left Icon Area */}
-
-
{/* Content Area */}
@@ -413,32 +1039,83 @@ function App() {
}}>
{new Date(item.created_at).toLocaleString()}
- {item.content}
-
+ {item.content_type === 'encrypted' ? (
+
+ 🔒 Encrypted — unlock vault to view
+
+ ) : item.content_type === 'image' ? (
+
+ {item.content}
+
+ )}
- {getTypeBadge(item.content_type)}
+ {getTypeBadge(item.content_type, item.content)}
+ {/* Tag pills */}
+ {(itemTags[item.id] ?? []).length > 0 && (
+
+ {(itemTags[item.id] ?? []).map(tag => (
+ { e.stopPropagation(); setActiveTagFilter(tag.id) }}
+ >
+ {tag.name}
+
+ ))}
+
+ )}
-
+
+ )}
+
+ {/* ── Plugins Modal ──────────────────────────────────────────────────── */}
+ {showPlugins && (
+
-
- {filteredItems.length} items
+ {/* Left — stats */}
+
+
+
+ {filteredItems.length} items
-
- {items.filter(i => i.pinned).length} pinned
+
+ {items.filter(i => i.pinned).length} pinned
-
- {items.filter(i => i.favorite).length} favorites
+
+ {items.filter(i => i.favorite).length} fav
-
- {items.filter(i => i.content_type.includes('image')).length} images
+
+ {items.filter(i => i.content_type === 'image').length} img
-
-
+ {/* Context Menu */}
+ {contextMenu && (
+
+ {settings.encryptionEnabled && hasPassword && (
+
{ setShowSettings(true); updateActivity() } : handleLockVault}
+ style={{
+ display: 'flex', alignItems: 'center', gap: '4px', cursor: 'pointer',
+ padding: '2px 7px', borderRadius: '5px',
+ backgroundColor: vaultLocked ? 'rgba(255,122,114,0.12)' : 'rgba(71,194,103,0.12)',
+ border: `1px solid ${vaultLocked ? 'rgba(255,122,114,0.3)' : 'rgba(71,194,103,0.3)'}`,
+ }}
+ title={vaultLocked ? 'Vault locked — click to unlock' : 'Vault unlocked — click to lock'}
+ >
+ {vaultLocked ? '🔒' : '🔓'}
+
+ {vaultLocked ? 'Locked' : 'Unlocked'}
+
+
+ )}
+
+
+
+
+ {/* Shortcuts tooltip trigger */}
+
+
?
+ {/* Tooltip */}
+
+ {[
+ ['⌘⇧V', 'Show / hide window'],
+ ['⌘⇧C', 'Quick paste latest'],
+ ['⌘K', 'Focus search'],
+ ['↑ ↓', 'Navigate'],
+ ['Enter', 'Copy selected'],
+ ['P', 'Pin selected'],
+ ['F', 'Favorite selected'],
+ ['D', 'Delete selected'],
+ ].map(([key, desc]) => (
+
+
+ {key}
+ {desc}
+
+ ))}
+ e.stopPropagation()}
+ >
+ {/* Current tags */}
+ {(itemTags[contextMenu.item.id] ?? []).length > 0 && (
+ <>
+
+ )}
+
+ {/* Settings Modal */}
+ {showSettings && (
+
+ Tags
+
+ {(itemTags[contextMenu.item.id] ?? []).map(tag => (
+
+
+
+ {tag.name}
+
+
+
+ ))}
+
+
+ )}
+ {/* Add tag row */}
+ {showTagInput ? (
+
+ setTagInput(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === 'Enter') {
+ handleAddTag(contextMenu.item, tagInput)
+ setTagInput('')
+ setShowTagInput(false)
+ setContextMenu(null)
+ }
+ if (e.key === 'Escape') {
+ setShowTagInput(false)
+ setTagInput('')
+ }
+ }}
+ placeholder="Tag name…"
+ style={{
+ flex: 1, padding: '5px 8px', backgroundColor: '#1F242B',
+ border: '1px solid #3A414C', borderRadius: '5px',
+ color: '#F3F5F8', fontSize: '13px', outline: 'none'
+ }}
+ />
+
+
+ ) : (
+ setShowTagInput(true)}
+ style={{
+ padding: '8px 10px', borderRadius: '6px', fontSize: '13px',
+ color: '#A7B0BC', cursor: 'pointer', display: 'flex', alignItems: 'center', gap: '8px'
+ }}
+ >
+ + Add tag
+
+ )}
+ {/* Other actions */}
+
+ { copyToClipboard(contextMenu.item.content); setContextMenu(null) }}
+ style={{
+ padding: '8px 10px', borderRadius: '6px', fontSize: '13px',
+ color: contextMenu.item.content_type === 'encrypted' ? '#5A6471' : '#A7B0BC',
+ cursor: contextMenu.item.content_type === 'encrypted' ? 'not-allowed' : 'pointer'
+ }}
+ >
+ Copy to clipboard
+
+ { togglePin(contextMenu.item); setContextMenu(null) }}
+ style={{ padding: '8px 10px', borderRadius: '6px', fontSize: '13px', color: '#A7B0BC', cursor: 'pointer' }}
+ >
+ {contextMenu.item.pinned ? 'Unpin' : 'Pin'}
+
+ { toggleFavorite(contextMenu.item); setContextMenu(null) }}
+ style={{ padding: '8px 10px', borderRadius: '6px', fontSize: '13px', color: '#A7B0BC', cursor: 'pointer' }}
+ >
+ {contextMenu.item.favorite ? 'Unfavorite' : 'Favorite'}
+
+ { deleteItem(contextMenu.item.id); setContextMenu(null) }}
+ style={{ padding: '8px 10px', borderRadius: '6px', fontSize: '13px', color: '#FF7A72', cursor: 'pointer' }}
+ >
+ Delete
+
+
+
+ )}
+
{/* Selected Item Detail Modal */}
{selectedItem && (
+
+
+
+
+ + Settings +
+ +
+ {/* Encryption Section */}
+
+
+
+
+ {/* Master Password Section */}
+ + Encryption +
+
+
+
+ Enable encryption
+
+ handleSettingsChange('encryptionEnabled', !settings.encryptionEnabled)}
+ style={{
+ width: '44px',
+ height: '24px',
+ backgroundColor: settings.encryptionEnabled ? '#6D7FFF' : '#3A414C',
+ borderRadius: '12px',
+ position: 'relative',
+ cursor: 'pointer',
+ transition: 'background-color 0.2s'
+ }}
+ >
+
+
+
+ Auto-lock after (min)
+ handleSettingsChange('autoLockMinutes', parseInt(e.target.value) || 0)}
+ style={{
+ width: '60px',
+ padding: '6px 8px',
+ backgroundColor: '#1F242B',
+ border: '1px solid #3A414C',
+ borderRadius: '6px',
+ color: '#F3F5F8',
+ fontSize: '14px'
+ }}
+ />
+
+
+
+
+ {/* Retention Section */}
+ + Master Password +
+
+ {!hasPassword ? (
+ /* No password configured — show set form */
+
+
+
+ Set a master password to enable AES-256-GCM encryption.
+
+ { setMasterPassword(e.target.value); setPasswordError(null) }}
+ style={{
+ padding: '8px 12px',
+ backgroundColor: '#1F242B',
+ border: '1px solid #3A414C',
+ borderRadius: '6px',
+ color: '#F3F5F8',
+ fontSize: '14px'
+ }}
+ />
+ { setConfirmPassword(e.target.value); setPasswordError(null) }}
+ onKeyDown={(e) => { if (e.key === 'Enter') handleSetMasterPassword() }}
+ style={{
+ padding: '8px 12px',
+ backgroundColor: '#1F242B',
+ border: '1px solid #3A414C',
+ borderRadius: '6px',
+ color: '#F3F5F8',
+ fontSize: '14px'
+ }}
+ />
+ {passwordError && (
+ {passwordError}
+ )}
+
+
+ ) : vaultLocked ? (
+ /* Password set, vault locked — show unlock form */
+
+
+ ) : (
+ /* Password set, vault unlocked — show lock button */
+
+ 🔒
+ Vault is locked
+
+ { setUnlockPassword(e.target.value); setUnlockError(null) }}
+ onKeyDown={(e) => { if (e.key === 'Enter') handleUnlockVault() }}
+ style={{
+ padding: '8px 12px',
+ backgroundColor: '#1F242B',
+ border: `1px solid ${unlockError ? '#FF7A72' : '#3A414C'}`,
+ borderRadius: '6px',
+ color: '#F3F5F8',
+ fontSize: '14px'
+ }}
+ />
+ {unlockError && (
+ {unlockError}
+ )}
+
+
+
+ )}
+
+
+ 🔓
+ Vault is unlocked
+
+
+ Clipboard data is being encrypted. Auto-lock after {settings.autoLockMinutes} min of inactivity.
+
+
+
+
+
+ {/* General Section */}
+ + Data Retention +
+
+
+
+ Max items
+ handleSettingsChange('maxItems', parseInt(e.target.value) || 0)}
+ style={{
+ width: '80px',
+ padding: '6px 8px',
+ backgroundColor: '#1F242B',
+ border: '1px solid #3A414C',
+ borderRadius: '6px',
+ color: '#F3F5F8',
+ fontSize: '14px'
+ }}
+ />
+
+
+ Retention days
+ handleSettingsChange('retentionDays', parseInt(e.target.value) || 0)}
+ style={{
+ width: '60px',
+ padding: '6px 8px',
+ backgroundColor: '#1F242B',
+ border: '1px solid #3A414C',
+ borderRadius: '6px',
+ color: '#F3F5F8',
+ fontSize: '14px'
+ }}
+ />
+
+
+
+
+ + General +
+
+
+
+ Auto-refresh interval (sec)
+ handleSettingsChange('refreshInterval', parseInt(e.target.value) || 0)}
+ style={{
+ width: '60px',
+ padding: '6px 8px',
+ backgroundColor: '#1F242B',
+ border: '1px solid #3A414C',
+ borderRadius: '6px',
+ color: '#F3F5F8',
+ fontSize: '14px'
+ }}
+ />
+
+
+ Show notifications
+
+ handleSettingsChange('showNotifications', !settings.showNotifications)}
+ style={{
+ width: '44px',
+ height: '24px',
+ backgroundColor: settings.showNotifications ? '#6D7FFF' : '#3A414C',
+ borderRadius: '12px',
+ position: 'relative',
+ cursor: 'pointer',
+ transition: 'background-color 0.2s'
+ }}
+ >
+
+
+
+ Launch at login
+
+ {
+ const next = !launchAtLogin
+ try {
+ await invoke('set_launch_at_login', { enabled: next })
+ setLaunchAtLogin(next)
+ } catch (e) {
+ console.error('Failed to set launch at login:', e)
+ }
+ }}
+ style={{
+ width: '44px',
+ height: '24px',
+ backgroundColor: launchAtLogin ? '#6D7FFF' : '#3A414C',
+ borderRadius: '12px',
+ position: 'relative',
+ cursor: 'pointer',
+ transition: 'background-color 0.2s'
+ }}
+ >
+
+
+
+
+
+
+
Content:
-
+
- {selectedItem.content}
-
+ {selectedItem.content_type === 'image' ? (
+
+ 
+
+ ) : (
+
+ {selectedItem.content}
+
+ )}
+
+
+ )}
+
+ {/* ── Sync Modal ──────────────────────────────────────────────────────── */}
+ {showSync && (
+
+ {/* Header */}
+
+
+
+
+
+
+
+ + Plugins +
+
+ Plugins are WebAssembly modules that transform clipboard text. Drop a{' '}
+ .wasm{' '}
+ file in ~/.local/share/openpaste/plugins/{' '}
+ or load one manually below.
+
+ {pluginError}
+
+ )}
+
+ {/* Load button */}
+
+
+ {/* Plugin list */}
+ {pluginLoading ? (
+ Loading…
+ ) : plugins.length === 0 ? (
+
+
+ ) : (
+
+ {plugins.map(plugin => (
+
+ )}
+
+ {/* Refresh button */}
+
+
+ ))}
+
+
+
+
+
+ {plugin.name}
+
+
+ {plugin.path}
+
+
+
+ {plugin.enabled ? 'Active' : 'Disabled'}
+
+
+
+
+
+
+
+ ,
+}
+
+// ── Server ────────────────────────────────────────────────────────────────────
-/// REST API server
pub struct ApiServer {
addr: SocketAddr,
+ db: Arc,
}
impl ApiServer {
- /// Create a new API server
- pub fn new(addr: SocketAddr) -> Self {
- Self { addr }
+ pub fn new(addr: SocketAddr, db: Arc) -> Self {
+ Self { addr, db }
}
- /// Build the router
- fn router() -> Router {
+ fn router(state: AppState) -> Router {
Router::new()
- .route("/api/v1/status", get(handlers::status))
- .route(
- "/api/v1/clipboard",
- get(handlers::get_clipboard).post(handlers::set_clipboard),
- )
- .route("/api/v1/search", post(handlers::search))
+ .route("/api/v1/status", get(status))
+ .route("/api/v1/clipboard", get(get_clipboard).post(set_clipboard))
+ .route("/api/v1/search", post(search))
+ .route("/api/v1/history", get(list_history))
+ .route("/api/v1/item/:id", get(get_item).delete(delete_item))
+ .route("/api/v1/sync/push", post(sync_push))
+ .route("/api/v1/sync/pull", get(sync_pull))
+ .with_state(state)
+ .layer(CorsLayer::permissive())
}
- /// Start the API server
pub async fn start(&self) -> Result<(), ApiError> {
- let app = Self::router();
+ let state = AppState {
+ db: self.db.clone(),
+ };
+ let app = Self::router(state);
let listener = TcpListener::bind(self.addr)
.await
- .map_err(|e: std::io::Error| ApiError::RequestFailed(e.to_string()))?;
+ .map_err(|e| ApiError::RequestFailed(e.to_string()))?;
+ tracing::info!("API server listening on {}", self.addr);
axum::serve(listener, app)
.await
- .map_err(|e: std::io::Error| ApiError::RequestFailed(e.to_string()))
+ .map_err(|e| ApiError::RequestFailed(e.to_string()))
}
}
-mod handlers {
- use axum::{response::IntoResponse, Json};
- use serde_json::json;
+// ── Handlers ──────────────────────────────────────────────────────────────────
- pub async fn status() -> impl IntoResponse {
- Json(json!({
- "status": "ok",
- "version": "0.1.0"
- }))
+async fn status() -> Json {
+ Json(json!({ "status": "ok", "version": env!("CARGO_PKG_VERSION") }))
+}
+
+#[derive(Deserialize)]
+struct PaginationParams {
+ #[serde(default = "default_limit")]
+ limit: usize,
+ #[serde(default)]
+ offset: usize,
+}
+fn default_limit() -> usize { 50 }
+
+async fn list_history(
+ State(state): State,
+ Query(params): Query,
+) -> Json {
+ match state.db.list_items(params.limit.min(200), params.offset).await {
+ Ok(items) => {
+ let out: Vec = items.iter().map(item_to_json).collect();
+ Json(json!({ "items": out, "total": out.len() }))
+ }
+ Err(e) => Json(json!({ "error": e.to_string() })),
+ }
+}
+
+async fn get_clipboard(State(state): State) -> Json {
+ match state.db.list_items(1, 0).await {
+ Ok(items) if !items.is_empty() => Json(json!({ "item": item_to_json(&items[0]) })),
+ Ok(_) => Json(json!({ "item": null })),
+ Err(e) => Json(json!({ "error": e.to_string() })),
}
+}
+
+#[derive(Deserialize)]
+struct SetClipboardBody {
+ content: String,
+ content_type: Option,
+}
+
+async fn set_clipboard(
+ State(state): State,
+ Json(body): Json,
+) -> Json {
+ use clipboard_db::models::ClipboardItem;
+ use md5;
+
+ let content_bytes = body.content.as_bytes().to_vec();
+ let hash = format!("{:x}", md5::compute(&content_bytes));
+ let ct = body.content_type.unwrap_or_else(|| "text".to_string());
+
+ let item = ClipboardItem {
+ id: 0,
+ content_type: ct,
+ content: content_bytes,
+ hash,
+ created_at: chrono::Utc::now(),
+ accessed_at: None,
+ pinned: false,
+ favorite: false,
+ nonce: None,
+ encrypted: false,
+ };
+
+ match state.db.insert_item(&item).await {
+ Ok(id) => Json(json!({ "id": id, "success": true })),
+ Err(e) if e.to_string().contains("UNIQUE") => {
+ Json(json!({ "success": true, "duplicate": true }))
+ }
+ Err(e) => Json(json!({ "error": e.to_string() })),
+ }
+}
+
+#[derive(Deserialize)]
+struct SearchBody {
+ query: String,
+ #[serde(default = "default_limit")]
+ limit: usize,
+ #[serde(default)]
+ offset: usize,
+}
+
+async fn search(
+ State(state): State,
+ Json(body): Json,
+) -> Json {
+ match state.db.search_items(&body.query, body.limit.min(200), body.offset).await {
+ Ok(items) => {
+ let out: Vec = items.iter().map(item_to_json).collect();
+ Json(json!({ "items": out }))
+ }
+ Err(e) => Json(json!({ "error": e.to_string() })),
+ }
+}
- pub async fn get_clipboard() -> impl IntoResponse {
- Json(json!({
- "success": false,
- "error": "Not implemented"
- }))
+async fn get_item(
+ State(state): State,
+ Path(id): Path,
+) -> Json {
+ match state.db.get_item(id).await {
+ Ok(item) => Json(json!({ "item": item_to_json(&item) })),
+ Err(e) => Json(json!({ "error": e.to_string() })),
}
+}
- pub async fn set_clipboard() -> impl IntoResponse {
- Json(json!({
- "success": false,
- "error": "Not implemented"
- }))
+async fn delete_item(
+ State(state): State,
+ Path(id): Path,
+) -> Json {
+ match state.db.delete_item(id).await {
+ Ok(_) => Json(json!({ "success": true })),
+ Err(e) => Json(json!({ "error": e.to_string() })),
}
+}
+
+// ── Sync endpoints ────────────────────────────────────────────────────────────
+// These implement the server side of the sync protocol described in clipboard-sync.
+
+#[derive(Deserialize)]
+struct SyncPushBody {
+ device_id: String,
+ items: Vec,
+}
+
+#[derive(Deserialize, Serialize)]
+struct SyncItemWire {
+ hash: String,
+ content_type: String,
+ content_b64: String,
+ created_at: String,
+ pinned: bool,
+ favorite: bool,
+ encrypted: bool,
+ nonce_b64: Option,
+}
+
+#[derive(Deserialize)]
+struct SyncPullParams {
+ device_id: String,
+ since: Option,
+}
+
+async fn sync_push(
+ State(state): State,
+ Json(body): Json,
+) -> Json {
+ use base64::{engine::general_purpose::STANDARD, Engine as _};
+ use clipboard_db::models::ClipboardItem;
+
+ tracing::info!("Sync push from device: {}", body.device_id);
+ let mut accepted = Vec::new();
+ let mut rejected = Vec::new();
+
+ for wire in body.items {
+ let content = match STANDARD.decode(&wire.content_b64) {
+ Ok(b) => b,
+ Err(_) => { rejected.push(wire.hash); continue; }
+ };
+ let nonce = wire.nonce_b64.as_deref().and_then(|n| STANDARD.decode(n).ok());
+ let created_at = match chrono::DateTime::parse_from_rfc3339(&wire.created_at) {
+ Ok(dt) => dt.with_timezone(&chrono::Utc),
+ Err(_) => { rejected.push(wire.hash); continue; }
+ };
+
+ let item = ClipboardItem {
+ id: 0,
+ content_type: wire.content_type,
+ content,
+ hash: wire.hash.clone(),
+ created_at,
+ accessed_at: None,
+ pinned: wire.pinned,
+ favorite: wire.favorite,
+ nonce,
+ encrypted: wire.encrypted,
+ };
- pub async fn search() -> impl IntoResponse {
- Json(json!({
- "success": false,
- "error": "Not implemented"
- }))
+ match state.db.insert_item(&item).await {
+ Ok(_) | Err(_) => accepted.push(wire.hash), // duplicates are also "accepted"
+ }
}
+
+ Json(json!({ "accepted": accepted, "rejected": rejected }))
+}
+
+async fn sync_pull(
+ State(state): State,
+ Query(params): Query,
+) -> Json {
+ use base64::{engine::general_purpose::STANDARD, Engine as _};
+
+ tracing::info!("Sync pull from device: {}", params.device_id);
+
+ // Fetch recent items (server just returns last 500; client filters by since)
+ let items = match state.db.list_items(500, 0).await {
+ Ok(i) => i,
+ Err(e) => return Json(json!({ "error": e.to_string() })),
+ };
+
+ let since = params.since.as_deref().unwrap_or("1970-01-01T00:00:00Z");
+
+ let wire_items: Vec = items
+ .into_iter()
+ .filter(|item| item.created_at.to_rfc3339().as_str() > since)
+ .map(|item| SyncItemWire {
+ hash: item.hash,
+ content_type: item.content_type,
+ content_b64: STANDARD.encode(&item.content),
+ created_at: item.created_at.to_rfc3339(),
+ pinned: item.pinned,
+ favorite: item.favorite,
+ encrypted: item.encrypted,
+ nonce_b64: item.nonce.as_deref().map(|n| STANDARD.encode(n)),
+ })
+ .collect();
+
+ Json(json!({ "items": wire_items }))
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+fn item_to_json(item: &clipboard_db::models::ClipboardItem) -> Value {
+ // Return text content as UTF-8 string; binary/encrypted as base64
+ let content_str = if item.encrypted {
+ "[encrypted]".to_string()
+ } else {
+ String::from_utf8_lossy(&item.content).to_string()
+ };
+
+ json!({
+ "id": item.id,
+ "content_type": item.content_type,
+ "content": content_str,
+ "hash": item.hash,
+ "created_at": item.created_at.to_rfc3339(),
+ "pinned": item.pinned,
+ "favorite": item.favorite,
+ "encrypted": item.encrypted,
+ })
}
diff --git a/crates/clipboard-api/src/main.rs b/crates/clipboard-api/src/main.rs
new file mode 100644
index 0000000..23e7823
--- /dev/null
+++ b/crates/clipboard-api/src/main.rs
@@ -0,0 +1,56 @@
+//! OpenPaste sync relay server
+//!
+//! Starts the HTTP API server so other devices can push/pull clipboard history.
+//!
+//! Usage:
+//! cargo run --bin clipboard-api -- --addr 0.0.0.0:8080
+//! OPENPASTE_API_ADDR=0.0.0.0:8080 cargo run --bin clipboard-api
+
+use anyhow::Result;
+use clipboard_api::ApiServer;
+use clipboard_db::Database;
+use std::net::SocketAddr;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+ // Basic logging
+ tracing_subscriber::fmt()
+ .with_env_filter(
+ tracing_subscriber::EnvFilter::from_default_env()
+ .add_directive(tracing::Level::INFO.into()),
+ )
+ .init();
+
+ // Resolve bind address — flag > env > default
+ let addr_str = std::env::args()
+ .skip_while(|a| a != "--addr")
+ .nth(1)
+ .or_else(|| std::env::var("OPENPASTE_API_ADDR").ok())
+ .unwrap_or_else(|| "127.0.0.1:8080".to_string());
+
+ let addr: SocketAddr = addr_str
+ .parse()
+ .map_err(|e| anyhow::anyhow!("Invalid address '{}': {}", addr_str, e))?;
+
+ // Use the same data directory as the daemon so they share the same DB
+ let data_dir = dirs::data_local_dir()
+ .unwrap_or_else(|| PathBuf::from("."))
+ .join("openpaste");
+
+ std::fs::create_dir_all(&data_dir)?;
+ let db_path = data_dir.join("clipboard.db");
+
+ tracing::info!("Opening database at {:?}", db_path);
+ let db = Arc::new(
+ Database::new(&db_path)
+ .await
+ .map_err(|e| anyhow::anyhow!("Database error: {}", e))?,
+ );
+
+ tracing::info!("OpenPaste API server listening on {}", addr);
+ ApiServer::new(addr, db).start().await?;
+
+ Ok(())
+}
diff --git a/crates/clipboard-core/Cargo.toml b/crates/clipboard-core/Cargo.toml
index 215508a..3f334e8 100644
--- a/crates/clipboard-core/Cargo.toml
+++ b/crates/clipboard-core/Cargo.toml
@@ -17,3 +17,4 @@ tracing = { workspace = true }
uuid = { workspace = true }
chrono = { workspace = true }
md5 = "0.7"
+arboard = "3.3"
diff --git a/crates/clipboard-core/src/clipboard.rs b/crates/clipboard-core/src/clipboard.rs
index 4a3f168..ef7e7d3 100644
--- a/crates/clipboard-core/src/clipboard.rs
+++ b/crates/clipboard-core/src/clipboard.rs
@@ -1,6 +1,7 @@
-//! Clipboard management
+//! Clipboard management — thin wrapper around arboard.
use crate::item::ClipboardItem;
+use crate::ContentType;
use thiserror::Error;
#[derive(Error, Debug)]
@@ -13,27 +14,57 @@ pub enum ClipboardError {
ContentTooLarge(usize),
}
-/// Clipboard manager for capturing and managing clipboard content
+/// Clipboard manager for reading and writing the system clipboard.
pub struct ClipboardManager {
- #[allow(dead_code)]
max_size: usize,
}
impl ClipboardManager {
- /// Create a new clipboard manager
+ /// Create a new clipboard manager.
+ /// `max_size` is the maximum content size in bytes that will be accepted.
pub fn new(max_size: usize) -> Self {
Self { max_size }
}
- /// Capture clipboard content
+ /// Read the current clipboard content.
+ ///
+ /// Tries text first; images are not handled here (use `clipboard-platform`
+ /// for full image + content-type detection).
pub async fn capture(&self) -> Result {
- // TODO: Implement platform-specific clipboard capture
- Err(ClipboardError::AccessFailed("Not implemented".to_string()))
+ let mut ctx = arboard::Clipboard::new()
+ .map_err(|e| ClipboardError::AccessFailed(e.to_string()))?;
+
+ let text = ctx
+ .get_text()
+ .map_err(|e| ClipboardError::AccessFailed(e.to_string()))?;
+
+ if text.is_empty() {
+ return Err(ClipboardError::AccessFailed("Clipboard is empty".to_string()));
+ }
+
+ let bytes = text.into_bytes();
+ if bytes.len() > self.max_size {
+ return Err(ClipboardError::ContentTooLarge(bytes.len()));
+ }
+
+ Ok(ClipboardItem::new(ContentType::Text, bytes))
}
- /// Set clipboard content
- pub async fn set(&self, _item: &ClipboardItem) -> Result<(), ClipboardError> {
- // TODO: Implement platform-specific clipboard setting
- Err(ClipboardError::AccessFailed("Not implemented".to_string()))
+ /// Write a clipboard item to the system clipboard.
+ ///
+ /// Only text content types are supported; image writes require the
+ /// platform-level API.
+ pub async fn set(&self, item: &ClipboardItem) -> Result<(), ClipboardError> {
+ match item.content_type {
+ ContentType::Image => return Err(ClipboardError::UnsupportedContentType),
+ _ => {}
+ }
+
+ let text = String::from_utf8_lossy(&item.content).to_string();
+ let mut ctx = arboard::Clipboard::new()
+ .map_err(|e| ClipboardError::AccessFailed(e.to_string()))?;
+
+ ctx.set_text(&text)
+ .map_err(|e| ClipboardError::AccessFailed(e.to_string()))
}
}
diff --git a/crates/clipboard-daemon/Cargo.toml b/crates/clipboard-daemon/Cargo.toml
index efc6837..0dc2876 100644
--- a/crates/clipboard-daemon/Cargo.toml
+++ b/crates/clipboard-daemon/Cargo.toml
@@ -27,3 +27,9 @@ clipboard-platform = { path = "../clipboard-platform" }
clipboard-events = { path = "../clipboard-events" }
clipboard-ipc = { path = "../clipboard-ipc" }
dirs = "5.0"
+notify-rust = { version = "4.11", features = ["d"] }
+chrono = { workspace = true }
+uuid = { workspace = true }
+clipboard-sync = { path = "../clipboard-sync" }
+clipboard-plugin = { path = "../clipboard-plugin" }
+clipboard-api = { path = "../clipboard-api" }
diff --git a/crates/clipboard-daemon/src/main.rs b/crates/clipboard-daemon/src/main.rs
index 97b6121..9acff6c 100644
--- a/crates/clipboard-daemon/src/main.rs
+++ b/crates/clipboard-daemon/src/main.rs
@@ -3,18 +3,18 @@
use anyhow::Result;
use clipboard_core::ClipboardItem;
use clipboard_db::Database;
-use clipboard_encryption::Encryption;
use clipboard_events::{Event, EventBus};
use clipboard_ipc::{IpcMessage, IpcServer};
use clipboard_platform::{get_provider, ClipboardProvider};
+use clipboard_plugin::PluginManager;
+use clipboard_sync::{SyncClient, SyncConfig};
use std::path::PathBuf;
use std::sync::Arc;
use tokio::signal;
-use tokio::sync::Mutex;
+use tokio::sync::{Mutex, RwLock};
use tracing::{error, info};
use tracing_subscriber::fmt;
use tracing_subscriber::EnvFilter;
-
#[tokio::main]
async fn main() -> Result<()> {
// Initialize logging
@@ -48,8 +48,25 @@ async fn main() -> Result<()> {
let _storage = Arc::new(clipboard_storage::Storage::new(&storage_path));
// Initialize encryption (placeholder key - should come from user password)
- let key = [0u8; 32]; // TODO: Get from user password
- let _encryption = Arc::new(Encryption::new(key));
+ let _key = [0u8; 32]; // TODO: Get from user password
+ let encryption = Arc::new(RwLock::new(None::));
+
+ // Initialize plugin manager
+ let plugin_manager = Arc::new(PluginManager::new());
+
+ // Load plugins from data_dir/plugins/*.wasm if any exist
+ let plugins_dir = data_dir.join("plugins");
+ std::fs::create_dir_all(&plugins_dir)?;
+ if let Ok(entries) = std::fs::read_dir(&plugins_dir) {
+ for entry in entries.flatten() {
+ if entry.path().extension().and_then(|e| e.to_str()) == Some("wasm") {
+ match plugin_manager.load(&entry.path()) {
+ Ok(name) => info!("Auto-loaded plugin: {}", name),
+ Err(e) => error!("Failed to load plugin {:?}: {}", entry.path(), e),
+ }
+ }
+ }
+ }
// Initialize event bus
let event_bus = Arc::new(EventBus::new(100));
@@ -63,6 +80,8 @@ async fn main() -> Result<()> {
let database = database.clone();
let event_bus = event_bus.clone();
let provider = provider.clone();
+ let encryption = encryption.clone();
+ let plugin_manager = plugin_manager.clone();
move |message: IpcMessage| -> std::pin::Pin + Send>> {
match message {
@@ -78,19 +97,40 @@ async fn main() -> Result<()> {
}
IpcMessage::GetHistory => {
let database_clone = database.clone();
+ let encryption_clone = encryption.clone();
Box::pin(async move {
match database_clone.list_items(100, 0).await {
Ok(items) => {
+ let encryption_guard = encryption_clone.read().await;
let history_items: Vec = items.into_iter().map(|item| {
+ let (content, content_type) = if item.encrypted {
+ if let Some(ref enc) = *encryption_guard {
+ match enc.decrypt(&clipboard_encryption::EncryptedData {
+ nonce: item.nonce.clone().unwrap_or_default(),
+ ciphertext: item.content.clone(),
+ }) {
+ Ok(decrypted) => (decrypted, item.content_type.clone()),
+ Err(_) => (b"[decryption failed]".to_vec(), "encrypted".to_string()),
+ }
+ } else {
+ // Vault locked — return placeholder, not raw ciphertext
+ (b"\xf0\x9f\x94\x92 Encrypted".to_vec(), "encrypted".to_string())
+ }
+ } else {
+ (item.content, item.content_type.clone())
+ };
+
clipboard_ipc::ClipboardHistoryItem {
id: item.id.to_string(),
- content_type: item.content_type,
- content: item.content,
+ content_type,
+ content,
hash: item.hash,
created_at: item.created_at.to_rfc3339(),
accessed_at: item.accessed_at.map(|t| t.to_rfc3339()),
pinned: item.pinned,
favorite: item.favorite,
+ nonce: item.nonce,
+ encrypted: item.encrypted,
}
}).collect();
IpcMessage::ClipboardHistory { items: history_items }
@@ -101,19 +141,39 @@ async fn main() -> Result<()> {
}
IpcMessage::SearchItems { query } => {
let database_clone = database.clone();
+ let encryption_clone = encryption.clone();
Box::pin(async move {
match database_clone.search_items(&query, 100, 0).await {
Ok(items) => {
+ let encryption_guard = encryption_clone.read().await;
let history_items: Vec = items.into_iter().map(|item| {
+ let (content, content_type) = if item.encrypted {
+ if let Some(ref enc) = *encryption_guard {
+ match enc.decrypt(&clipboard_encryption::EncryptedData {
+ nonce: item.nonce.clone().unwrap_or_default(),
+ ciphertext: item.content.clone(),
+ }) {
+ Ok(decrypted) => (decrypted, item.content_type.clone()),
+ Err(_) => (b"[decryption failed]".to_vec(), "encrypted".to_string()),
+ }
+ } else {
+ (b"\xf0\x9f\x94\x92 Encrypted".to_vec(), "encrypted".to_string())
+ }
+ } else {
+ (item.content, item.content_type.clone())
+ };
+
clipboard_ipc::ClipboardHistoryItem {
id: item.id.to_string(),
- content_type: item.content_type,
- content: item.content,
+ content_type,
+ content,
hash: item.hash,
created_at: item.created_at.to_rfc3339(),
accessed_at: item.accessed_at.map(|t| t.to_rfc3339()),
pinned: item.pinned,
favorite: item.favorite,
+ nonce: item.nonce,
+ encrypted: item.encrypted,
}
}).collect();
IpcMessage::ClipboardHistory { items: history_items }
@@ -126,21 +186,41 @@ async fn main() -> Result<()> {
let provider_clone = provider.clone();
let database_clone = database.clone();
let event_bus_clone = event_bus.clone();
+ let encryption_clone = encryption.clone();
let item = ClipboardItem::new(clipboard_core::ContentType::Text, content.clone());
Box::pin(async move {
let provider = provider_clone.lock().await;
match provider.set_content(&item).await {
Ok(_) => {
+ // Encrypt if encryption is enabled
+ let (content_to_store, nonce, encrypted) = {
+ let encryption_guard = encryption_clone.read().await;
+ if let Some(ref enc) = *encryption_guard {
+ match enc.encrypt(&item.content) {
+ Ok(encrypted_data) => (encrypted_data.ciphertext, Some(encrypted_data.nonce), true),
+ Err(e) => {
+ error!("Encryption failed: {}, storing unencrypted", e);
+ (item.content.clone(), None, false)
+ }
+ }
+ } else {
+ (item.content.clone(), None, false)
+ }
+ };
+ drop(encryption_clone);
+
// Convert to DB model and save
let db_item = clipboard_db::models::ClipboardItem {
id: 0, // Will be auto-assigned
content_type: item.content_type.to_string(),
- content: item.content.clone(),
+ content: content_to_store,
hash: item.hash,
created_at: item.created_at,
accessed_at: item.accessed_at,
pinned: item.pinned,
favorite: item.favorite,
+ nonce,
+ encrypted,
};
let _ = database_clone.insert_item(&db_item).await;
@@ -181,6 +261,378 @@ async fn main() -> Result<()> {
}
})
}
+ IpcMessage::GetSettings => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ // Load settings from database
+ let settings = match database_clone.get_setting("max_items").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(10000),
+ _ => 10000,
+ };
+ let retention = match database_clone.get_setting("retention_days").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(90),
+ _ => 90,
+ };
+ let encryption = match database_clone.get_setting("encryption_enabled").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(false),
+ _ => false,
+ };
+ let auto_lock = match database_clone.get_setting("auto_lock_minutes").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(5),
+ _ => 5,
+ };
+ let refresh = match database_clone.get_setting("refresh_interval").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(2),
+ _ => 2,
+ };
+ let notifications = match database_clone.get_setting("show_notifications").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(true),
+ _ => true,
+ };
+
+ IpcMessage::Settings {
+ settings: clipboard_ipc::AppSettings {
+ encryption_enabled: encryption,
+ auto_lock_minutes: auto_lock,
+ max_items: settings,
+ retention_days: retention,
+ refresh_interval: refresh,
+ show_notifications: notifications,
+ }
+ }
+ })
+ }
+ IpcMessage::SaveSettings { settings } => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ // Save settings to database
+ let results = vec![
+ database_clone.upsert_setting("max_items", &settings.max_items.to_string()).await,
+ database_clone.upsert_setting("retention_days", &settings.retention_days.to_string()).await,
+ database_clone.upsert_setting("encryption_enabled", &settings.encryption_enabled.to_string()).await,
+ database_clone.upsert_setting("auto_lock_minutes", &settings.auto_lock_minutes.to_string()).await,
+ database_clone.upsert_setting("refresh_interval", &settings.refresh_interval.to_string()).await,
+ database_clone.upsert_setting("show_notifications", &settings.show_notifications.to_string()).await,
+ ];
+
+ if results.iter().all(|r| r.is_ok()) {
+ IpcMessage::Success
+ } else {
+ IpcMessage::Error { message: "Failed to save some settings".to_string() }
+ }
+ })
+ }
+ IpcMessage::SetMasterPassword { password } => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ use clipboard_encryption::KeyDerivation;
+ let key_derivation = KeyDerivation::new();
+
+ // Hash the password and store it
+ match key_derivation.hash_password(&password) {
+ Ok(hash) => {
+ // Generate and store salt for key derivation
+ let salt = KeyDerivation::generate_salt();
+ match database_clone.upsert_setting("encryption_salt", &salt).await {
+ Ok(_) => {
+ match database_clone.upsert_setting("master_password_hash", &hash).await {
+ Ok(_) => IpcMessage::Success,
+ Err(e) => IpcMessage::Error { message: format!("Failed to store password: {}", e) },
+ }
+ }
+ Err(e) => IpcMessage::Error { message: format!("Failed to store salt: {}", e) },
+ }
+ }
+ Err(e) => IpcMessage::Error { message: format!("Failed to hash password: {}", e) },
+ }
+ })
+ }
+ IpcMessage::UnlockVault { password } => {
+ let database_clone = database.clone();
+ let encryption_clone = encryption.clone();
+ Box::pin(async move {
+ use clipboard_encryption::KeyDerivation;
+ let key_derivation = KeyDerivation::new();
+
+ // Get stored password hash and salt
+ let stored_hash = match database_clone.get_setting("master_password_hash").await {
+ Ok(Some(hash)) => hash,
+ Ok(None) => return IpcMessage::Error { message: "No master password set".to_string() },
+ Err(e) => return IpcMessage::Error { message: format!("Failed to get password: {}", e) },
+ };
+
+ let salt = match database_clone.get_setting("encryption_salt").await {
+ Ok(Some(s)) => s,
+ Ok(None) => return IpcMessage::Error { message: "No encryption salt found".to_string() },
+ Err(e) => return IpcMessage::Error { message: format!("Failed to get salt: {}", e) },
+ };
+
+ match key_derivation.verify(&password, &stored_hash) {
+ Ok(true) => {
+ // Derive encryption key from password using stored salt
+ match key_derivation.derive_key(&password, &salt) {
+ Ok(key) => {
+ use clipboard_encryption::Encryption;
+ let enc = Encryption::new(key);
+ *encryption_clone.write().await = Some(enc);
+ IpcMessage::Success
+ }
+ Err(e) => IpcMessage::Error { message: format!("Failed to derive key: {}", e) },
+ }
+ }
+ Ok(false) => IpcMessage::Error { message: "Invalid password".to_string() },
+ Err(e) => IpcMessage::Error { message: format!("Verification failed: {}", e) },
+ }
+ })
+ }
+ IpcMessage::LockVault => {
+ let encryption_clone = encryption.clone();
+ Box::pin(async move {
+ *encryption_clone.write().await = None;
+ IpcMessage::Success
+ })
+ }
+ IpcMessage::CheckVaultStatus => {
+ let database_clone = database.clone();
+ let encryption_clone = encryption.clone();
+ Box::pin(async move {
+ // Check if master password is configured
+ let has_password = matches!(
+ database_clone.get_setting("master_password_hash").await,
+ Ok(Some(_))
+ );
+
+ if !has_password {
+ // No password configured — vault feature not set up
+ return IpcMessage::VaultStatus { is_locked: false };
+ }
+
+ // Password is configured: locked = encryption key not loaded in memory
+ let encryption_guard = encryption_clone.read().await;
+ let is_locked = encryption_guard.is_none();
+ IpcMessage::VaultStatus { is_locked }
+ })
+ }
+ IpcMessage::HasMasterPassword => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ let has_password = matches!(
+ database_clone.get_setting("master_password_hash").await,
+ Ok(Some(_))
+ );
+ IpcMessage::PasswordConfigured { has_password }
+ })
+ }
+ // ── Tag handlers ──────────────────────────────────────────────
+ IpcMessage::ListTags => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ match database_clone.list_tags().await {
+ Ok(tags) => IpcMessage::TagsList {
+ tags: tags.into_iter().map(|t| clipboard_ipc::TagItem {
+ id: t.id, name: t.name, color: t.color,
+ }).collect()
+ },
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ IpcMessage::CreateTag { name, color } => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ match database_clone.create_tag(&name, color.as_deref()).await {
+ Ok(_) => IpcMessage::Success,
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ IpcMessage::DeleteTag { id } => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ match database_clone.delete_tag(id).await {
+ Ok(_) => IpcMessage::Success,
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ IpcMessage::GetItemTags { item_id } => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ match database_clone.get_item_tags(item_id).await {
+ Ok(tags) => IpcMessage::ItemTags {
+ tags: tags.into_iter().map(|t| clipboard_ipc::TagItem {
+ id: t.id, name: t.name, color: t.color,
+ }).collect()
+ },
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ IpcMessage::AddTagToItem { item_id, tag_name, color } => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ // Create tag if needed, then assign
+ match database_clone.create_tag(&tag_name, color.as_deref()).await {
+ Ok(tag_id) => {
+ // create_tag returns last_insert_rowid which is 0 on conflict update
+ // fetch the actual id by name
+ let actual_id = match database_clone.list_tags().await {
+ Ok(tags) => tags.into_iter()
+ .find(|t| t.name == tag_name)
+ .map(|t| t.id)
+ .unwrap_or(tag_id),
+ Err(_) => tag_id,
+ };
+ match database_clone.add_tag_to_item(item_id, actual_id).await {
+ Ok(_) => IpcMessage::Success,
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ }
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ IpcMessage::RemoveTagFromItem { item_id, tag_id } => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ match database_clone.remove_tag_from_item(item_id, tag_id).await {
+ Ok(_) => IpcMessage::Success,
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ IpcMessage::ListItemsByTag { tag_id } => {
+ let database_clone = database.clone();
+ let encryption_clone = encryption.clone();
+ Box::pin(async move {
+ match database_clone.list_items_by_tag(tag_id, 100, 0).await {
+ Ok(items) => {
+ let encryption_guard = encryption_clone.read().await;
+ let history_items = items.into_iter().map(|item| {
+ let (content, content_type) = if item.encrypted {
+ if let Some(ref enc) = *encryption_guard {
+ match enc.decrypt(&clipboard_encryption::EncryptedData {
+ nonce: item.nonce.clone().unwrap_or_default(),
+ ciphertext: item.content.clone(),
+ }) {
+ Ok(d) => (d, item.content_type.clone()),
+ Err(_) => (b"[decryption failed]".to_vec(), "encrypted".to_string()),
+ }
+ } else {
+ (b"\xf0\x9f\x94\x92 Encrypted".to_vec(), "encrypted".to_string())
+ }
+ } else {
+ (item.content, item.content_type.clone())
+ };
+ clipboard_ipc::ClipboardHistoryItem {
+ id: item.id.to_string(),
+ content_type,
+ content,
+ hash: item.hash,
+ created_at: item.created_at.to_rfc3339(),
+ accessed_at: item.accessed_at.map(|t| t.to_rfc3339()),
+ pinned: item.pinned,
+ favorite: item.favorite,
+ nonce: item.nonce,
+ encrypted: item.encrypted,
+ }
+ }).collect();
+ IpcMessage::ClipboardHistory { items: history_items }
+ }
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ // ── Sync handlers ─────────────────────────────────────────────
+ IpcMessage::GetSyncConfig => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ let server_url = database_clone.get_setting("sync_server_url").await
+ .ok().flatten().unwrap_or_default();
+ let api_token = database_clone.get_setting("sync_api_token").await
+ .ok().flatten();
+ let enabled = database_clone.get_setting("sync_enabled").await
+ .ok().flatten().and_then(|v| v.parse::().ok()).unwrap_or(false);
+ let last_sync_at = database_clone.get_setting("last_sync_at").await
+ .ok().flatten();
+ IpcMessage::SyncConfig { server_url, api_token, enabled, last_sync_at }
+ })
+ }
+ IpcMessage::SetSyncConfig { server_url, api_token, enabled } => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ let results = vec![
+ database_clone.upsert_setting("sync_server_url", &server_url).await,
+ database_clone.upsert_setting("sync_enabled", &enabled.to_string()).await,
+ ];
+ if let Some(token) = &api_token {
+ let _ = database_clone.upsert_setting("sync_api_token", token).await;
+ }
+ if results.iter().all(|r| r.is_ok()) {
+ IpcMessage::Success
+ } else {
+ IpcMessage::Error { message: "Failed to save sync config".to_string() }
+ }
+ })
+ }
+ IpcMessage::SyncNow => {
+ let database_clone = database.clone();
+ Box::pin(async move {
+ let server_url = match database_clone.get_setting("sync_server_url").await {
+ Ok(Some(url)) if !url.is_empty() => url,
+ _ => return IpcMessage::Error { message: "Sync server not configured".to_string() },
+ };
+ let api_token = database_clone.get_setting("sync_api_token").await.ok().flatten();
+ let device_id = database_clone.get_setting("device_id").await.ok().flatten()
+ .unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
+ // Persist device_id if new
+ let _ = database_clone.upsert_setting("device_id", &device_id).await;
+
+ let config = SyncConfig { server_url, device_id, api_token };
+ let client = SyncClient::new(config, database_clone.clone());
+ let last_sync = database_clone.get_setting("last_sync_at").await.ok().flatten();
+ match client.sync_once(last_sync.as_deref()).await {
+ Ok((pushed, pulled)) => {
+ let now = chrono::Utc::now().to_rfc3339();
+ let _ = database_clone.upsert_setting("last_sync_at", &now).await;
+ IpcMessage::ClipboardContent {
+ content: format!("pushed={}, pulled={}", pushed, pulled).into_bytes()
+ }
+ }
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ // ── Plugin handlers ────────────────────────────────────────────
+ IpcMessage::ListPlugins => {
+ let pm = plugin_manager.clone();
+ Box::pin(async move {
+ let plugins = pm.list().into_iter().map(|p| clipboard_ipc::PluginInfoItem {
+ name: p.name,
+ path: p.path.to_string_lossy().to_string(),
+ enabled: p.enabled,
+ }).collect();
+ IpcMessage::PluginList { plugins }
+ })
+ }
+ IpcMessage::LoadPlugin { path } => {
+ let pm = plugin_manager.clone();
+ Box::pin(async move {
+ match pm.load(std::path::Path::new(&path)) {
+ Ok(name) => IpcMessage::ClipboardContent { content: name.into_bytes() },
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
+ IpcMessage::UnloadPlugin { name } => {
+ let pm = plugin_manager.clone();
+ Box::pin(async move {
+ match pm.unload(&name) {
+ Ok(_) => IpcMessage::Success,
+ Err(e) => IpcMessage::Error { message: e.to_string() },
+ }
+ })
+ }
_ => Box::pin(async move { IpcMessage::Error { message: "Invalid message".to_string() } }),
}
}
@@ -196,8 +648,10 @@ async fn main() -> Result<()> {
let provider_watch = provider.clone();
let event_bus_watch = event_bus.clone();
let database_watch = database.clone();
+ let encryption_watch = encryption.clone();
tokio::spawn(async move {
let mut last_hash = String::new();
+ let mut is_startup = true; // suppress notification for the initial clipboard snapshot
let mut interval = tokio::time::interval(tokio::time::Duration::from_millis(500));
loop {
@@ -207,25 +661,80 @@ async fn main() -> Result<()> {
match provider.get_content().await {
Ok(item) => {
if item.hash != last_hash {
+ let is_new_capture = !is_startup;
last_hash = item.hash.clone();
+ is_startup = false;
+
+ if !is_new_capture {
+ // First tick — just record current hash, no save, no notification
+ continue;
+ }
+
info!("Clipboard changed: hash={}", item.hash);
// Publish clipboard change event
let event = Event::ClipboardAdded { id: item.id };
let _ = event_bus_watch.publish(event);
- // Save to database
+ // Encrypt if encryption is enabled
+ let (content_to_store, nonce, encrypted) = {
+ let encryption_guard = encryption_watch.read().await;
+ if let Some(ref enc) = *encryption_guard {
+ match enc.encrypt(&item.content) {
+ Ok(encrypted_data) => (encrypted_data.ciphertext, Some(encrypted_data.nonce), true),
+ Err(e) => {
+ error!("Encryption failed: {}, storing unencrypted", e);
+ (item.content.clone(), None, false)
+ }
+ }
+ } else {
+ (item.content.clone(), None, false)
+ }
+ };
+
+ // Save to database — silently skip duplicates (UNIQUE constraint on hash)
let db_item = clipboard_db::models::ClipboardItem {
- id: 0, // Will be auto-assigned
+ id: 0,
content_type: item.content_type.to_string(),
- content: item.content.clone(),
+ content: content_to_store,
hash: item.hash,
created_at: item.created_at,
accessed_at: item.accessed_at,
pinned: item.pinned,
favorite: item.favorite,
+ nonce,
+ encrypted,
+ };
+ // Send notification if enabled
+ let show_notifications = match database_watch.get_setting("show_notifications").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(true),
+ _ => true,
};
- let _ = database_watch.insert_item(&db_item).await;
+ if show_notifications {
+ let preview: String = if item.content_type.to_string() == "image" {
+ "📷 Image captured".to_string()
+ } else {
+ let text = String::from_utf8_lossy(&item.content);
+ let truncated = text.chars().take(60).collect::();
+ if text.len() > 60 { format!("{}…", truncated) } else { truncated }
+ };
+ let _ = notify_rust::Notification::new()
+ .summary("OpenPaste")
+ .body(&preview)
+ .timeout(notify_rust::Timeout::Milliseconds(2500))
+ .show();
+ }
+
+ match database_watch.insert_item(&db_item).await {
+ Ok(_) => {}
+ Err(e) => {
+ let msg = e.to_string();
+ // UNIQUE constraint = duplicate, not a real error
+ if !msg.contains("UNIQUE") {
+ error!("Failed to save clipboard item: {}", msg);
+ }
+ }
+ }
}
}
Err(e) => {
@@ -235,6 +744,45 @@ async fn main() -> Result<()> {
}
});
+ // Start periodic cleanup task
+ let database_cleanup = database.clone();
+ tokio::spawn(async move {
+ let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(3600)); // Run every hour
+
+ loop {
+ interval.tick().await;
+
+ // Load retention settings
+ let max_items = match database_cleanup.get_setting("max_items").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(10000),
+ _ => 10000,
+ };
+ let retention_days = match database_cleanup.get_setting("retention_days").await {
+ Ok(Some(val)) => val.parse::().unwrap_or(90),
+ _ => 90,
+ };
+
+ // Run cleanup
+ match database_cleanup.cleanup_old_items(retention_days).await {
+ Ok(deleted) => {
+ if deleted > 0 {
+ info!("Cleaned up {} items older than {} days", deleted, retention_days);
+ }
+ }
+ Err(e) => error!("Failed to cleanup old items: {}", e),
+ }
+
+ match database_cleanup.enforce_max_items(max_items).await {
+ Ok(deleted) => {
+ if deleted > 0 {
+ info!("Deleted {} items to enforce max items limit of {}", deleted, max_items);
+ }
+ }
+ Err(e) => error!("Failed to enforce max items: {}", e),
+ }
+ }
+ });
+
// Setup graceful shutdown
let shutdown_signal = async {
signal::ctrl_c()
diff --git a/crates/clipboard-db/migrations/001_initial.sql b/crates/clipboard-db/migrations/001_initial.sql
index 788d959..a10c250 100644
--- a/crates/clipboard-db/migrations/001_initial.sql
+++ b/crates/clipboard-db/migrations/001_initial.sql
@@ -9,7 +9,9 @@ CREATE TABLE IF NOT EXISTS clipboard_items (
created_at TEXT NOT NULL,
accessed_at TEXT,
pinned INTEGER NOT NULL DEFAULT 0,
- favorite INTEGER NOT NULL DEFAULT 0
+ favorite INTEGER NOT NULL DEFAULT 0,
+ nonce BLOB,
+ encrypted INTEGER NOT NULL DEFAULT 0
);
-- FTS5 virtual table for full-text search
@@ -63,6 +65,7 @@ CREATE TABLE IF NOT EXISTS clipboard_item_tags (
CREATE TABLE IF NOT EXISTS settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL,
+ value_type TEXT NOT NULL DEFAULT 'string',
updated_at TEXT NOT NULL
);
diff --git a/crates/clipboard-db/src/database.rs b/crates/clipboard-db/src/database.rs
index 05c1b25..389eeeb 100644
--- a/crates/clipboard-db/src/database.rs
+++ b/crates/clipboard-db/src/database.rs
@@ -51,8 +51,8 @@ impl Database {
pub async fn insert_item(&self, item: &ClipboardItem) -> Result {
let result = sqlx::query(
r#"
- INSERT INTO clipboard_items (content_type, content, hash, created_at, accessed_at, pinned, favorite)
- VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
+ INSERT INTO clipboard_items (content_type, content, hash, created_at, accessed_at, pinned, favorite, nonce, encrypted)
+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)
"#,
)
.bind(&item.content_type)
@@ -62,6 +62,8 @@ impl Database {
.bind(item.accessed_at)
.bind(item.pinned)
.bind(item.favorite)
+ .bind(&item.nonce)
+ .bind(item.encrypted)
.execute(&self.pool)
.await
.map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
@@ -72,7 +74,7 @@ impl Database {
/// Get a clipboard item by ID
pub async fn get_item(&self, id: i64) -> Result {
let item = sqlx::query_as::<_, ClipboardItem>(
- "SELECT id, content_type, content, hash, created_at, accessed_at, pinned, favorite FROM clipboard_items WHERE id = ?"
+ "SELECT id, content_type, content, hash, created_at, accessed_at, pinned, favorite, nonce, encrypted FROM clipboard_items WHERE id = ?"
)
.bind(id)
.fetch_optional(&self.pool)
@@ -90,7 +92,7 @@ impl Database {
offset: usize,
) -> Result, DatabaseError> {
let items = sqlx::query_as::<_, ClipboardItem>(
- "SELECT id, content_type, content, hash, created_at, accessed_at, pinned, favorite FROM clipboard_items ORDER BY created_at DESC LIMIT ? OFFSET ?"
+ "SELECT id, content_type, content, hash, created_at, accessed_at, pinned, favorite, nonce, encrypted FROM clipboard_items ORDER BY created_at DESC LIMIT ? OFFSET ?"
)
.bind(limit as i64)
.bind(offset as i64)
@@ -143,7 +145,7 @@ impl Database {
) -> Result, DatabaseError> {
let items = sqlx::query_as::<_, ClipboardItem>(
r#"
- SELECT ci.id, ci.content_type, ci.content, ci.hash, ci.created_at, ci.accessed_at, ci.pinned, ci.favorite
+ SELECT ci.id, ci.content_type, ci.content, ci.hash, ci.created_at, ci.accessed_at, ci.pinned, ci.favorite, ci.nonce, ci.encrypted
FROM clipboard_items ci
INNER JOIN clipboard_items_fts fts ON ci.id = fts.rowid
WHERE clipboard_items_fts MATCH ?
@@ -160,4 +162,406 @@ impl Database {
Ok(items)
}
+
+ /// Get a setting value by key
+ pub async fn get_setting(&self, key: &str) -> Result, DatabaseError> {
+ let result = sqlx::query_as::<_, (String,)>(
+ "SELECT value FROM settings WHERE key = ?"
+ )
+ .bind(key)
+ .fetch_optional(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+
+ Ok(result.map(|r| r.0))
+ }
+
+ /// Upsert a setting value
+ pub async fn upsert_setting(&self, key: &str, value: &str) -> Result<(), DatabaseError> {
+ sqlx::query(
+ r#"
+ INSERT INTO settings (key, value, value_type, updated_at)
+ VALUES (?1, ?2, 'string', strftime('%s', 'now') * 1000)
+ ON CONFLICT(key) DO UPDATE SET
+ value = ?2,
+ updated_at = strftime('%s', 'now') * 1000
+ "#
+ )
+ .bind(key)
+ .bind(value)
+ .execute(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+
+ Ok(())
+ }
+
+ /// Delete items older than retention days
+ pub async fn cleanup_old_items(&self, retention_days: i32) -> Result {
+ let cutoff_time = chrono::Utc::now() - chrono::Duration::days(retention_days as i64);
+ let cutoff_str = cutoff_time.to_rfc3339();
+
+ let result = sqlx::query(
+ "DELETE FROM clipboard_items WHERE created_at < ?"
+ )
+ .bind(cutoff_str)
+ .execute(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+
+ Ok(result.rows_affected())
+ }
+
+ /// Enforce max items limit by deleting oldest items
+ pub async fn enforce_max_items(&self, max_items: i32) -> Result {
+ let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM clipboard_items")
+ .fetch_one(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+
+ let max_items_i64 = max_items as i64;
+
+ if count <= max_items_i64 {
+ return Ok(0);
+ }
+
+ let to_delete = count - max_items_i64;
+
+ let result = sqlx::query(
+ r#"
+ DELETE FROM clipboard_items
+ WHERE id IN (
+ SELECT id FROM clipboard_items
+ ORDER BY created_at ASC
+ LIMIT ?
+ )
+ "#
+ )
+ .bind(to_delete)
+ .execute(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+
+ Ok(result.rows_affected())
+ }
+
+ // ── Tag operations ────────────────────────────────────────────────────────
+
+ /// List all tags
+ pub async fn list_tags(&self) -> Result, DatabaseError> {
+ let tags = sqlx::query_as::<_, crate::models::Tag>(
+ "SELECT id, name, color FROM tags ORDER BY name ASC"
+ )
+ .fetch_all(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+ Ok(tags)
+ }
+
+ /// Create a tag (upsert by name)
+ pub async fn create_tag(&self, name: &str, color: Option<&str>) -> Result {
+ let result = sqlx::query(
+ "INSERT INTO tags (name, color) VALUES (?1, ?2) ON CONFLICT(name) DO UPDATE SET color = ?2"
+ )
+ .bind(name)
+ .bind(color)
+ .execute(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+ Ok(result.last_insert_rowid())
+ }
+
+ /// Delete a tag and all its assignments
+ pub async fn delete_tag(&self, id: i64) -> Result<(), DatabaseError> {
+ sqlx::query("DELETE FROM tags WHERE id = ?")
+ .bind(id)
+ .execute(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+ Ok(())
+ }
+
+ /// Get tags assigned to a clipboard item
+ pub async fn get_item_tags(&self, item_id: i64) -> Result, DatabaseError> {
+ let tags = sqlx::query_as::<_, crate::models::Tag>(
+ r#"
+ SELECT t.id, t.name, t.color
+ FROM tags t
+ INNER JOIN clipboard_item_tags cit ON t.id = cit.tag_id
+ WHERE cit.clipboard_item_id = ?
+ ORDER BY t.name ASC
+ "#
+ )
+ .bind(item_id)
+ .fetch_all(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+ Ok(tags)
+ }
+
+ /// Add a tag to a clipboard item (no-op if already assigned)
+ pub async fn add_tag_to_item(&self, item_id: i64, tag_id: i64) -> Result<(), DatabaseError> {
+ sqlx::query(
+ "INSERT OR IGNORE INTO clipboard_item_tags (clipboard_item_id, tag_id) VALUES (?1, ?2)"
+ )
+ .bind(item_id)
+ .bind(tag_id)
+ .execute(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+ Ok(())
+ }
+
+ /// Remove a tag from a clipboard item
+ pub async fn remove_tag_from_item(&self, item_id: i64, tag_id: i64) -> Result<(), DatabaseError> {
+ sqlx::query(
+ "DELETE FROM clipboard_item_tags WHERE clipboard_item_id = ?1 AND tag_id = ?2"
+ )
+ .bind(item_id)
+ .bind(tag_id)
+ .execute(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+ Ok(())
+ }
+
+ /// List clipboard items that have a given tag
+ pub async fn list_items_by_tag(
+ &self,
+ tag_id: i64,
+ limit: usize,
+ offset: usize,
+ ) -> Result, DatabaseError> {
+ let items = sqlx::query_as::<_, ClipboardItem>(
+ r#"
+ SELECT ci.id, ci.content_type, ci.content, ci.hash, ci.created_at,
+ ci.accessed_at, ci.pinned, ci.favorite, ci.nonce, ci.encrypted
+ FROM clipboard_items ci
+ INNER JOIN clipboard_item_tags cit ON ci.id = cit.clipboard_item_id
+ WHERE cit.tag_id = ?
+ ORDER BY ci.created_at DESC
+ LIMIT ? OFFSET ?
+ "#
+ )
+ .bind(tag_id)
+ .bind(limit as i64)
+ .bind(offset as i64)
+ .fetch_all(&self.pool)
+ .await
+ .map_err(|e| DatabaseError::QueryFailed(e.to_string()))?;
+ Ok(items)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::models::ClipboardItem;
+ use chrono::Utc;
+
+ fn make_item(content: &str, content_type: &str) -> ClipboardItem {
+ let content_bytes = content.as_bytes().to_vec();
+ // Simple hash: hex of a basic checksum, sufficient for test uniqueness
+ let hash = format!("{:016x}", content_bytes.iter().fold(0u64, |acc, &b| acc.wrapping_mul(31).wrapping_add(b as u64)));
+ ClipboardItem {
+ id: 0,
+ content_type: content_type.to_string(),
+ content: content_bytes,
+ hash,
+ created_at: Utc::now(),
+ accessed_at: None,
+ pinned: false,
+ favorite: false,
+ nonce: None,
+ encrypted: false,
+ }
+ }
+
+ #[tokio::test]
+ async fn test_insert_and_list() {
+ let db = Database::in_memory().await.unwrap();
+ let item = make_item("hello world", "text");
+ let id = db.insert_item(&item).await.unwrap();
+ assert!(id > 0);
+
+ let items = db.list_items(10, 0).await.unwrap();
+ assert_eq!(items.len(), 1);
+ assert_eq!(items[0].content, b"hello world");
+ assert_eq!(items[0].content_type, "text");
+ }
+
+ #[tokio::test]
+ async fn test_get_item() {
+ let db = Database::in_memory().await.unwrap();
+ let id = db.insert_item(&make_item("get me", "text")).await.unwrap();
+ let item = db.get_item(id).await.unwrap();
+ assert_eq!(item.id, id);
+ assert_eq!(item.content, b"get me");
+ }
+
+ #[tokio::test]
+ async fn test_delete_item() {
+ let db = Database::in_memory().await.unwrap();
+ let id = db.insert_item(&make_item("delete me", "text")).await.unwrap();
+ db.delete_item(id).await.unwrap();
+ let items = db.list_items(10, 0).await.unwrap();
+ assert!(items.iter().all(|i| i.id != id));
+ }
+
+ #[tokio::test]
+ async fn test_toggle_pin_and_favorite() {
+ let db = Database::in_memory().await.unwrap();
+ let id = db.insert_item(&make_item("pin me", "text")).await.unwrap();
+
+ db.toggle_pin(id).await.unwrap();
+ let item = db.get_item(id).await.unwrap();
+ assert!(item.pinned);
+
+ db.toggle_pin(id).await.unwrap();
+ let item = db.get_item(id).await.unwrap();
+ assert!(!item.pinned);
+
+ db.toggle_favorite(id).await.unwrap();
+ let item = db.get_item(id).await.unwrap();
+ assert!(item.favorite);
+ }
+
+ #[tokio::test]
+ async fn test_duplicate_hash_rejected() {
+ let db = Database::in_memory().await.unwrap();
+ let item = make_item("unique content", "text");
+ db.insert_item(&item).await.unwrap();
+ // Second insert with same hash should fail with UNIQUE constraint
+ let result = db.insert_item(&item).await;
+ assert!(result.is_err());
+ assert!(result.unwrap_err().to_string().contains("UNIQUE"));
+ }
+
+ #[tokio::test]
+ async fn test_settings_upsert_and_get() {
+ let db = Database::in_memory().await.unwrap();
+ db.upsert_setting("test_key", "value1").await.unwrap();
+ let val = db.get_setting("test_key").await.unwrap();
+ assert_eq!(val, Some("value1".to_string()));
+
+ // Upsert again — should overwrite
+ db.upsert_setting("test_key", "value2").await.unwrap();
+ let val = db.get_setting("test_key").await.unwrap();
+ assert_eq!(val, Some("value2".to_string()));
+ }
+
+ #[tokio::test]
+ async fn test_get_missing_setting_returns_none() {
+ let db = Database::in_memory().await.unwrap();
+ let val = db.get_setting("nonexistent").await.unwrap();
+ assert_eq!(val, None);
+ }
+
+ #[tokio::test]
+ async fn test_tag_crud() {
+ let db = Database::in_memory().await.unwrap();
+
+ // Create tag
+ db.create_tag("work", Some("#ff0000")).await.unwrap();
+ let tags = db.list_tags().await.unwrap();
+ assert_eq!(tags.len(), 1);
+ assert_eq!(tags[0].name, "work");
+ assert_eq!(tags[0].color.as_deref(), Some("#ff0000"));
+
+ // Upsert same name — should not duplicate
+ db.create_tag("work", Some("#00ff00")).await.unwrap();
+ let tags = db.list_tags().await.unwrap();
+ assert_eq!(tags.len(), 1);
+
+ // Delete
+ let tag_id = tags[0].id;
+ db.delete_tag(tag_id).await.unwrap();
+ let tags = db.list_tags().await.unwrap();
+ assert!(tags.is_empty());
+ }
+
+ #[tokio::test]
+ async fn test_item_tags() {
+ let db = Database::in_memory().await.unwrap();
+ let item_id = db.insert_item(&make_item("tagged item", "text")).await.unwrap();
+
+ db.create_tag("personal", None).await.unwrap();
+ let tags = db.list_tags().await.unwrap();
+ let tag_id = tags[0].id;
+
+ db.add_tag_to_item(item_id, tag_id).await.unwrap();
+ let item_tags = db.get_item_tags(item_id).await.unwrap();
+ assert_eq!(item_tags.len(), 1);
+ assert_eq!(item_tags[0].name, "personal");
+
+ db.remove_tag_from_item(item_id, tag_id).await.unwrap();
+ let item_tags = db.get_item_tags(item_id).await.unwrap();
+ assert!(item_tags.is_empty());
+ }
+
+ #[tokio::test]
+ async fn test_list_items_by_tag() {
+ let db = Database::in_memory().await.unwrap();
+ let id1 = db.insert_item(&make_item("item one", "text")).await.unwrap();
+ let _id2 = db.insert_item(&make_item("item two", "text")).await.unwrap();
+
+ db.create_tag("filtered", None).await.unwrap();
+ let tags = db.list_tags().await.unwrap();
+ let tag_id = tags[0].id;
+
+ db.add_tag_to_item(id1, tag_id).await.unwrap();
+ let results = db.list_items_by_tag(tag_id, 10, 0).await.unwrap();
+ assert_eq!(results.len(), 1);
+ assert_eq!(results[0].id, id1);
+ }
+
+ #[tokio::test]
+ async fn test_cleanup_old_items() {
+ let db = Database::in_memory().await.unwrap();
+ // Insert an item with a very old timestamp
+ let old_item = ClipboardItem {
+ id: 0,
+ content_type: "text".to_string(),
+ content: b"old".to_vec(),
+ hash: "oldhash123".to_string(),
+ created_at: Utc::now() - chrono::Duration::days(100),
+ accessed_at: None,
+ pinned: false,
+ favorite: false,
+ nonce: None,
+ encrypted: false,
+ };
+ db.insert_item(&old_item).await.unwrap();
+ let new_id = db.insert_item(&make_item("new item", "text")).await.unwrap();
+
+ let deleted = db.cleanup_old_items(30).await.unwrap();
+ assert_eq!(deleted, 1);
+
+ let items = db.list_items(10, 0).await.unwrap();
+ assert_eq!(items.len(), 1);
+ assert_eq!(items[0].id, new_id);
+ }
+
+ #[tokio::test]
+ async fn test_enforce_max_items() {
+ let db = Database::in_memory().await.unwrap();
+ for i in 0..5 {
+ db.insert_item(&make_item(&format!("item {}", i), "text")).await.unwrap();
+ }
+ let deleted = db.enforce_max_items(3).await.unwrap();
+ assert_eq!(deleted, 2);
+ let items = db.list_items(10, 0).await.unwrap();
+ assert_eq!(items.len(), 3);
+ }
+
+ #[tokio::test]
+ async fn test_search_items() {
+ let db = Database::in_memory().await.unwrap();
+ db.insert_item(&make_item("the quick brown fox", "text")).await.unwrap();
+ db.insert_item(&make_item("hello world", "text")).await.unwrap();
+
+ let results = db.search_items("quick", 10, 0).await.unwrap();
+ assert_eq!(results.len(), 1);
+ assert!(String::from_utf8_lossy(&results[0].content).contains("quick"));
+ }
}
diff --git a/crates/clipboard-db/src/models.rs b/crates/clipboard-db/src/models.rs
index 75c18cd..fc02f20 100644
--- a/crates/clipboard-db/src/models.rs
+++ b/crates/clipboard-db/src/models.rs
@@ -4,7 +4,13 @@ use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use sqlx::FromRow;
-/// Clipboard item database model
+/// Tag model
+#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
+pub struct Tag {
+ pub id: i64,
+ pub name: String,
+ pub color: Option,
+}
#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
pub struct ClipboardItem {
pub id: i64,
@@ -15,4 +21,6 @@ pub struct ClipboardItem {
pub accessed_at: Option>,
pub pinned: bool,
pub favorite: bool,
+ pub nonce: Option>,
+ pub encrypted: bool,
}
diff --git a/crates/clipboard-encryption/src/encryption.rs b/crates/clipboard-encryption/src/encryption.rs
index 15e6bfd..543b3db 100644
--- a/crates/clipboard-encryption/src/encryption.rs
+++ b/crates/clipboard-encryption/src/encryption.rs
@@ -51,3 +51,77 @@ impl Encryption {
.map_err(|e: aes_gcm::aead::Error| EncryptionError::DecryptionFailed(e.to_string()))
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn test_key() -> [u8; 32] {
+ let mut key = [0u8; 32];
+ for (i, b) in key.iter_mut().enumerate() {
+ *b = i as u8;
+ }
+ key
+ }
+
+ #[test]
+ fn test_encrypt_decrypt_roundtrip() {
+ let enc = Encryption::new(test_key());
+ let plaintext = b"hello, OpenPaste!";
+ let encrypted = enc.encrypt(plaintext).unwrap();
+ assert!(!encrypted.ciphertext.is_empty());
+ assert_eq!(encrypted.nonce.len(), 12); // AES-GCM nonce is 12 bytes
+ let decrypted = enc.decrypt(&encrypted).unwrap();
+ assert_eq!(decrypted, plaintext);
+ }
+
+ #[test]
+ fn test_encrypt_produces_different_ciphertexts() {
+ // Each call should produce a different nonce → different ciphertext
+ let enc = Encryption::new(test_key());
+ let plaintext = b"same plaintext";
+ let e1 = enc.encrypt(plaintext).unwrap();
+ let e2 = enc.encrypt(plaintext).unwrap();
+ // Nonces should differ (probabilistically guaranteed)
+ assert_ne!(e1.nonce, e2.nonce);
+ }
+
+ #[test]
+ fn test_decrypt_with_wrong_key_fails() {
+ let enc = Encryption::new(test_key());
+ let encrypted = enc.encrypt(b"secret").unwrap();
+
+ let mut wrong_key = test_key();
+ wrong_key[0] ^= 0xff;
+ let enc2 = Encryption::new(wrong_key);
+ assert!(enc2.decrypt(&encrypted).is_err());
+ }
+
+ #[test]
+ fn test_decrypt_with_tampered_ciphertext_fails() {
+ let enc = Encryption::new(test_key());
+ let mut encrypted = enc.encrypt(b"integrity check").unwrap();
+ // Flip a byte in the ciphertext — AEAD should detect this
+ if let Some(b) = encrypted.ciphertext.last_mut() {
+ *b ^= 0x01;
+ }
+ assert!(enc.decrypt(&encrypted).is_err());
+ }
+
+ #[test]
+ fn test_empty_plaintext() {
+ let enc = Encryption::new(test_key());
+ let encrypted = enc.encrypt(b"").unwrap();
+ let decrypted = enc.decrypt(&encrypted).unwrap();
+ assert_eq!(decrypted, b"");
+ }
+
+ #[test]
+ fn test_large_plaintext() {
+ let enc = Encryption::new(test_key());
+ let plaintext = vec![0xABu8; 1024 * 1024]; // 1 MB
+ let encrypted = enc.encrypt(&plaintext).unwrap();
+ let decrypted = enc.decrypt(&encrypted).unwrap();
+ assert_eq!(decrypted, plaintext);
+ }
+}
diff --git a/crates/clipboard-encryption/src/key_derivation.rs b/crates/clipboard-encryption/src/key_derivation.rs
index 0ec176b..1568b82 100644
--- a/crates/clipboard-encryption/src/key_derivation.rs
+++ b/crates/clipboard-encryption/src/key_derivation.rs
@@ -79,3 +79,62 @@ impl KeyDerivation {
.map_err(|_| EncryptionError::InvalidPassword)
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_derive_key_is_deterministic() {
+ let kd = KeyDerivation::new();
+ let salt = KeyDerivation::generate_salt();
+ let key1 = kd.derive_key("password123", &salt).unwrap();
+ let key2 = kd.derive_key("password123", &salt).unwrap();
+ assert_eq!(key1, key2);
+ }
+
+ #[test]
+ fn test_derive_key_differs_for_different_passwords() {
+ let kd = KeyDerivation::new();
+ let salt = KeyDerivation::generate_salt();
+ let key1 = kd.derive_key("password123", &salt).unwrap();
+ let key2 = kd.derive_key("different!", &salt).unwrap();
+ assert_ne!(key1, key2);
+ }
+
+ #[test]
+ fn test_derive_key_differs_for_different_salts() {
+ let kd = KeyDerivation::new();
+ let salt1 = KeyDerivation::generate_salt();
+ let salt2 = KeyDerivation::generate_salt();
+ let key1 = kd.derive_key("password", &salt1).unwrap();
+ let key2 = kd.derive_key("password", &salt2).unwrap();
+ assert_ne!(key1, key2);
+ }
+
+ #[test]
+ fn test_hash_and_verify_password() {
+ let kd = KeyDerivation::new();
+ let hash = kd.hash_password("my_secure_password").unwrap();
+ assert!(!hash.is_empty());
+ // Correct password verifies
+ assert!(kd.verify("my_secure_password", &hash).unwrap());
+ }
+
+ #[test]
+ fn test_wrong_password_fails_verification() {
+ let kd = KeyDerivation::new();
+ let hash = kd.hash_password("correct_password").unwrap();
+ let result = kd.verify("wrong_password", &hash);
+ // Should return Err(InvalidPassword)
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_derived_key_is_32_bytes() {
+ let kd = KeyDerivation::new();
+ let salt = KeyDerivation::generate_salt();
+ let key = kd.derive_key("anything", &salt).unwrap();
+ assert_eq!(key.len(), 32);
+ }
+}
diff --git a/crates/clipboard-ipc/src/ipc.rs b/crates/clipboard-ipc/src/ipc.rs
index c2a632f..28d96da 100644
--- a/crates/clipboard-ipc/src/ipc.rs
+++ b/crates/clipboard-ipc/src/ipc.rs
@@ -21,20 +21,103 @@ pub enum IpcMessage {
TogglePin { id: i64 },
/// Toggle favorite status
ToggleFavorite { id: i64 },
+ /// Get settings
+ GetSettings,
+ /// Save settings
+ SaveSettings { settings: AppSettings },
+ /// Set master password
+ SetMasterPassword { password: String },
+ /// Unlock vault with password
+ UnlockVault { password: String },
+ /// Lock vault
+ LockVault,
+ /// Check if vault is locked
+ CheckVaultStatus,
+ /// Check if a master password has been configured
+ HasMasterPassword,
+ // ── Tag operations ────────────────────────────────────────────────────────
+ /// List all tags
+ ListTags,
+ /// Create or upsert a tag
+ CreateTag { name: String, color: Option },
+ /// Delete a tag by id
+ DeleteTag { id: i64 },
+ /// Get tags for a clipboard item
+ GetItemTags { item_id: i64 },
+ /// Add a tag to a clipboard item (creates tag if needed)
+ AddTagToItem { item_id: i64, tag_name: String, color: Option },
+ /// Remove a tag from a clipboard item
+ RemoveTagFromItem { item_id: i64, tag_id: i64 },
+ /// List items with a given tag
+ ListItemsByTag { tag_id: i64 },
+ // ── Sync operations ───────────────────────────────────────────────────────
+ /// Get sync configuration (server_url, device_id, enabled)
+ GetSyncConfig,
+ /// Save sync configuration
+ SetSyncConfig { server_url: String, api_token: Option, enabled: bool },
+ /// Trigger an immediate sync cycle
+ SyncNow,
+ // ── Plugin operations ─────────────────────────────────────────────────────
+ /// List loaded plugins
+ ListPlugins,
+ /// Load a plugin from an absolute path
+ LoadPlugin { path: String },
+ /// Unload a plugin by name
+ UnloadPlugin { name: String },
/// Clipboard content response
ClipboardContent { content: Vec },
/// Clipboard history response
ClipboardHistory { items: Vec },
+ /// Settings response
+ Settings { settings: AppSettings },
+ /// Vault status response
+ VaultStatus { is_locked: bool },
+ /// Whether a master password has been configured
+ PasswordConfigured { has_password: bool },
+ /// Tags list response
+ TagsList { tags: Vec },
+ /// Tags for a single item
+ ItemTags { tags: Vec },
+ /// Sync configuration response
+ SyncConfig { server_url: String, api_token: Option, enabled: bool, last_sync_at: Option },
+ /// Plugin list response
+ PluginList { plugins: Vec },
/// Success response
Success,
/// Error response
Error { message: String },
}
+/// Application settings
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AppSettings {
+ pub encryption_enabled: bool,
+ pub auto_lock_minutes: i32,
+ pub max_items: i32,
+ pub retention_days: i32,
+ pub refresh_interval: i32,
+ pub show_notifications: bool,
+}
+
+/// Tag item for IPC
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TagItem {
+ pub id: i64,
+ pub name: String,
+ pub color: Option,
+}
+
+/// Plugin info for IPC
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PluginInfoItem {
+ pub name: String,
+ pub path: String,
+ pub enabled: bool,
+}
+
/// Clipboard history item for IPC
#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct ClipboardHistoryItem {
- pub id: String,
+pub struct ClipboardHistoryItem { pub id: String,
pub content_type: String,
pub content: Vec,
pub hash: String,
@@ -42,6 +125,8 @@ pub struct ClipboardHistoryItem {
pub accessed_at: Option,
pub pinned: bool,
pub favorite: bool,
+ pub nonce: Option>,
+ pub encrypted: bool,
}
/// IPC server
diff --git a/crates/clipboard-ipc/src/lib.rs b/crates/clipboard-ipc/src/lib.rs
index 9ccda1f..aa92995 100644
--- a/crates/clipboard-ipc/src/lib.rs
+++ b/crates/clipboard-ipc/src/lib.rs
@@ -4,4 +4,4 @@ pub mod error;
pub mod ipc;
pub use error::IpcError;
-pub use ipc::{ClipboardHistoryItem, IpcClient, IpcMessage, IpcServer};
+pub use ipc::{AppSettings, ClipboardHistoryItem, IpcClient, IpcMessage, IpcServer, PluginInfoItem, TagItem};
diff --git a/crates/clipboard-platform/Cargo.toml b/crates/clipboard-platform/Cargo.toml
index 820c599..67e5345 100644
--- a/crates/clipboard-platform/Cargo.toml
+++ b/crates/clipboard-platform/Cargo.toml
@@ -17,6 +17,7 @@ tracing = { workspace = true }
clipboard-core = { path = "../clipboard-core" }
async-trait = "0.1"
arboard = "3.3"
+image = { version = "0.25", default-features = false, features = ["png"] }
[target.'cfg(windows)'.dependencies]
clipboard-win = "4.5"
diff --git a/crates/clipboard-platform/src/provider.rs b/crates/clipboard-platform/src/provider.rs
index 03a6c33..3a9baea 100644
--- a/crates/clipboard-platform/src/provider.rs
+++ b/crates/clipboard-platform/src/provider.rs
@@ -2,12 +2,12 @@
use crate::PlatformError;
use async_trait::async_trait;
-use clipboard_core::ClipboardItem;
+use clipboard_core::{ClipboardItem, ContentType};
/// Platform-agnostic clipboard provider trait
#[async_trait]
pub trait ClipboardProvider: Send + Sync {
- /// Get clipboard content
+ /// Get clipboard content — tries image first, then text
async fn get_content(&self) -> Result;
/// Set clipboard content
@@ -17,231 +17,218 @@ pub trait ClipboardProvider: Send + Sync {
async fn watch_changes(&self) -> Result<(), PlatformError>;
}
-/// Platform-specific provider enum
-#[derive(Clone)]
-pub enum PlatformProvider {
- #[cfg(windows)]
- Windows(windows::WindowsProvider),
- #[cfg(target_os = "linux")]
- Linux(linux::LinuxProvider),
- #[cfg(target_os = "macos")]
- Macos(macos::MacosProvider),
+// ── Shared helpers ────────────────────────────────────────────────────────────
+
+/// Encode raw RGBA pixels as a PNG byte vector.
+fn rgba_to_png(width: usize, height: usize, bytes: &[u8]) -> Result, String> {
+ use image::{ImageBuffer, RgbaImage};
+ let img: RgbaImage = ImageBuffer::from_raw(width as u32, height as u32, bytes.to_vec())
+ .ok_or_else(|| "Invalid image dimensions".to_string())?;
+ let mut buf = std::io::Cursor::new(Vec::new());
+ img.write_to(&mut buf, image::ImageFormat::Png)
+ .map_err(|e| e.to_string())?;
+ Ok(buf.into_inner())
}
-#[async_trait]
-impl ClipboardProvider for PlatformProvider {
- async fn get_content(&self) -> Result {
- match self {
- #[cfg(windows)]
- PlatformProvider::Windows(p) => p.get_content().await,
- #[cfg(target_os = "linux")]
- PlatformProvider::Linux(p) => p.get_content().await,
- #[cfg(target_os = "macos")]
- PlatformProvider::Macos(p) => p.get_content().await,
- #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
- _ => Err(PlatformError::UnsupportedPlatform),
- }
- }
+/// Detect a richer content type from plain text.
+fn detect_text_type(text: &str) -> ContentType {
+ let trimmed = text.trim();
- async fn set_content(&self, item: &ClipboardItem) -> Result<(), PlatformError> {
- match self {
- #[cfg(windows)]
- PlatformProvider::Windows(p) => p.set_content(item).await,
- #[cfg(target_os = "linux")]
- PlatformProvider::Linux(p) => p.set_content(item).await,
- #[cfg(target_os = "macos")]
- PlatformProvider::Macos(p) => p.set_content(item).await,
- #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
- _ => Err(PlatformError::UnsupportedPlatform),
- }
- }
-
- async fn watch_changes(&self) -> Result<(), PlatformError> {
- match self {
- #[cfg(windows)]
- PlatformProvider::Windows(p) => p.watch_changes().await,
- #[cfg(target_os = "linux")]
- PlatformProvider::Linux(p) => p.watch_changes().await,
- #[cfg(target_os = "macos")]
- PlatformProvider::Macos(p) => p.watch_changes().await,
- #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
- _ => Err(PlatformError::UnsupportedPlatform),
- }
- }
-}
-
-/// Get the appropriate clipboard provider for the current platform
-pub fn get_provider() -> Result {
- #[cfg(windows)]
+ // HTML
+ if trimmed.starts_with("(trimmed).is_ok() {
+ return ContentType::Code;
+ }
}
- #[cfg(target_os = "macos")]
- {
- Ok(PlatformProvider::Macos(macos::MacosProvider::new()))
+ // Code heuristics
+ let code_indicators = [
+ "fn ", "def ", "class ", "import ", "use ", "const ", "let ", "var ",
+ "function ", "return ", "if (", "for (", "while (", "#include", "public ",
+ "private ", "async ", "await ", "=>", "->", "::", "$(", "#!/",
+ ];
+ let code_score: usize = code_indicators
+ .iter()
+ .filter(|&&pat| trimmed.contains(pat))
+ .count();
+ let lines: Vec<&str> = trimmed.lines().collect();
+ let indented_lines = lines
+ .iter()
+ .filter(|l| l.starts_with(" ") || l.starts_with('\t'))
+ .count();
+ if code_score >= 2 || (lines.len() > 3 && indented_lines > 1) {
+ return ContentType::Code;
}
- #[cfg(not(any(windows, target_os = "linux", target_os = "macos")))]
- {
- Err(PlatformError::UnsupportedPlatform)
- }
+ ContentType::Text
}
-#[cfg(windows)]
-mod windows {
- use super::*;
- use arboard::Clipboard;
- use clipboard_core::{ClipboardItem, ContentType};
-
- #[derive(Clone)]
- pub struct WindowsProvider;
-
- impl WindowsProvider {
- pub fn new() -> Self {
- Self
+/// On macOS, check whether the pasteboard currently advertises an image type,
+/// without actually reading the image data. This avoids the ~50 ms arboard
+/// penalty on every poll when the clipboard contains only text.
+///
+/// Returns `true` → image type is present, go ahead and call `get_image()`.
+/// Returns `false` → skip image attempt entirely.
+#[cfg(target_os = "macos")]
+#[allow(unexpected_cfgs)]
+fn pasteboard_has_image() -> bool {
+ // Use the Objective-C runtime to call
+ // [[NSPasteboard generalPasteboard] canReadObjectForClasses:...] or
+ // more simply check the types array for common image UTIs.
+ //
+ // We do this via a tiny inline Objective-C call using the `objc` crate
+ // that is already a transitive dependency.
+ use std::ffi::CStr;
+ unsafe {
+ use objc::runtime::{Class, Object};
+ use objc::{msg_send, sel, sel_impl};
+
+ let cls = match Class::get("NSPasteboard") {
+ Some(c) => c,
+ None => return false,
+ };
+ let pb: *mut Object = msg_send![cls, generalPasteboard];
+ if pb.is_null() {
+ return false;
}
- }
-
- #[async_trait]
- impl ClipboardProvider for WindowsProvider {
- async fn get_content(&self) -> Result {
- let mut ctx =
- Clipboard::new().map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
-
- let text = ctx
- .get_text()
- .map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
-
- let content_bytes = text.into_bytes();
- let content_type = ContentType::detect(&content_bytes);
-
- Ok(ClipboardItem::new(content_type, content_bytes))
+ let types: *mut Object = msg_send![pb, types];
+ if types.is_null() {
+ return false;
}
-
- async fn set_content(&self, item: &ClipboardItem) -> Result<(), PlatformError> {
- if item.content_type == ContentType::Text {
- let text = String::from_utf8_lossy(&item.content).to_string();
- let mut ctx =
- Clipboard::new().map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
-
- ctx.set_text(&text)
- .map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
+ let count: usize = msg_send![types, count];
+ for i in 0..count {
+ let type_str: *mut Object = msg_send![types, objectAtIndex: i];
+ if type_str.is_null() {
+ continue;
+ }
+ let utf8: *const std::os::raw::c_char = msg_send![type_str, UTF8String];
+ if utf8.is_null() {
+ continue;
+ }
+ let s = CStr::from_ptr(utf8).to_string_lossy();
+ // Common image UTIs advertised by macOS apps
+ if s.contains("image")
+ || s == "public.png"
+ || s == "public.jpeg"
+ || s == "public.tiff"
+ || s == "com.apple.pict"
+ {
+ return true;
}
- // TODO: Handle other content types
- Ok(())
- }
-
- async fn watch_changes(&self) -> Result<(), PlatformError> {
- // TODO: Implement Windows clipboard watching using clipboard format listeners
- Err(PlatformError::WatchFailed("Not implemented".to_string()))
}
+ false
}
}
-#[cfg(target_os = "linux")]
-mod linux {
- use super::*;
- use arboard::Clipboard;
- use clipboard_core::{ClipboardItem, ContentType};
-
- #[derive(Clone)]
- pub struct LinuxProvider;
-
- impl LinuxProvider {
- pub fn new() -> Self {
- Self
- }
- }
-
- #[async_trait]
- impl ClipboardProvider for LinuxProvider {
- async fn get_content(&self) -> Result {
- let mut ctx =
- Clipboard::new().map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
-
- let text = ctx
- .get_text()
- .map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
-
- let content_bytes = text.into_bytes();
- let content_type = ContentType::detect(&content_bytes);
-
- Ok(ClipboardItem::new(content_type, content_bytes))
- }
-
- async fn set_content(&self, item: &ClipboardItem) -> Result<(), PlatformError> {
- if item.content_type == ContentType::Text {
- let text = String::from_utf8_lossy(&item.content).to_string();
- let mut ctx =
- Clipboard::new().map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
-
- ctx.set_text(&text)
- .map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
- }
- // TODO: Handle other content types
- Ok(())
- }
+#[cfg(not(target_os = "macos"))]
+fn pasteboard_has_image() -> bool {
+ // On Linux/Windows we always attempt get_image(); arboard is fast there.
+ true
+}
- async fn watch_changes(&self) -> Result<(), PlatformError> {
- // TODO: Implement clipboard watching using wl-clipboard or x11 events
- Err(PlatformError::WatchFailed("Not implemented".to_string()))
- }
+/// Try to read image from clipboard, encode as PNG.
+fn try_get_image() -> Option> {
+ if !pasteboard_has_image() {
+ return None;
}
+ let mut ctx = arboard::Clipboard::new().ok()?;
+ let img = ctx.get_image().ok()?;
+ rgba_to_png(img.width, img.height, &img.bytes).ok()
}
-#[cfg(target_os = "macos")]
-mod macos {
- use super::*;
- use arboard::Clipboard;
- use clipboard_core::{ClipboardItem, ContentType};
-
- #[derive(Clone)]
- pub struct MacosProvider;
+/// Read text from clipboard.
+fn try_get_text() -> Option {
+ let mut ctx = arboard::Clipboard::new().ok()?;
+ let text = ctx.get_text().ok()?;
+ if text.is_empty() { None } else { Some(text) }
+}
- impl MacosProvider {
- pub fn new() -> Self {
- Self
+/// Build a ClipboardItem from the current clipboard state.
+/// Prefers images over text.
+pub(crate) fn read_clipboard_item() -> Result {
+ if let Some(png_bytes) = try_get_image() {
+ return Ok(ClipboardItem::new(ContentType::Image, png_bytes));
+ }
+ match try_get_text() {
+ Some(text) => {
+ let content_type = detect_text_type(&text);
+ Ok(ClipboardItem::new(content_type, text.into_bytes()))
}
+ None => Err(PlatformError::AccessFailed("Clipboard is empty".to_string())),
}
+}
- #[async_trait]
- impl ClipboardProvider for MacosProvider {
- async fn get_content(&self) -> Result {
- let mut ctx =
- Clipboard::new().map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
-
- let text = ctx
- .get_text()
- .map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
+/// Write text to the system clipboard.
+pub(crate) fn write_text(text: &str) -> Result<(), PlatformError> {
+ let mut ctx =
+ arboard::Clipboard::new().map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
+ ctx.set_text(text)
+ .map_err(|e| PlatformError::AccessFailed(e.to_string()))
+}
- let content_bytes = text.into_bytes();
- let content_type = ContentType::detect(&content_bytes);
+// ── Platform enum ─────────────────────────────────────────────────────────────
- Ok(ClipboardItem::new(content_type, content_bytes))
- }
+#[derive(Clone)]
+pub enum PlatformProvider {
+ #[cfg(target_os = "macos")]
+ Macos,
+ #[cfg(target_os = "linux")]
+ Linux,
+ #[cfg(windows)]
+ Windows,
+}
- async fn set_content(&self, item: &ClipboardItem) -> Result<(), PlatformError> {
- if item.content_type == ContentType::Text {
- let text = String::from_utf8_lossy(&item.content).to_string();
- let mut ctx =
- Clipboard::new().map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
+#[async_trait]
+impl ClipboardProvider for PlatformProvider {
+ async fn get_content(&self) -> Result {
+ read_clipboard_item()
+ }
- ctx.set_text(&text)
+ async fn set_content(&self, item: &ClipboardItem) -> Result<(), PlatformError> {
+ match item.content_type {
+ ContentType::Image => {
+ let img = image::load_from_memory(&item.content)
+ .map_err(|e| PlatformError::AccessFailed(e.to_string()))?
+ .to_rgba8();
+ let (w, h) = img.dimensions();
+ let mut ctx = arboard::Clipboard::new()
.map_err(|e| PlatformError::AccessFailed(e.to_string()))?;
+ ctx.set_image(arboard::ImageData {
+ width: w as usize,
+ height: h as usize,
+ bytes: img.into_raw().into(),
+ })
+ .map_err(|e| PlatformError::AccessFailed(e.to_string()))
+ }
+ _ => {
+ let text = String::from_utf8_lossy(&item.content).to_string();
+ write_text(&text)
}
- // TODO: Handle other content types
- Ok(())
}
+ }
- async fn watch_changes(&self) -> Result<(), PlatformError> {
- // TODO: Implement clipboard watching using NSPasteboard notifications
- Err(PlatformError::WatchFailed("Not implemented".to_string()))
- }
+ async fn watch_changes(&self) -> Result<(), PlatformError> {
+ Err(PlatformError::WatchFailed("Not implemented".to_string()))
}
}
+
+pub fn get_provider() -> Result {
+ #[cfg(target_os = "macos")]
+ return Ok(PlatformProvider::Macos);
+ #[cfg(target_os = "linux")]
+ return Ok(PlatformProvider::Linux);
+ #[cfg(windows)]
+ return Ok(PlatformProvider::Windows);
+ #[allow(unreachable_code)]
+ Err(PlatformError::UnsupportedPlatform)
+}
diff --git a/crates/clipboard-plugin/src/plugin.rs b/crates/clipboard-plugin/src/plugin.rs
index 0e655a9..caacdf3 100644
--- a/crates/clipboard-plugin/src/plugin.rs
+++ b/crates/clipboard-plugin/src/plugin.rs
@@ -1,11 +1,45 @@
-//! Plugin manager implementation
+//! Plugin manager — loads WASM plugins and applies them to clipboard items.
+//!
+//! Plugin contract (guest side):
+//! - Export: `process_item(ptr: i32, len: i32) -> i32`
+//! Receives a UTF-8 string (the clipboard text content) at [ptr..ptr+len]
+//! in the guest's linear memory.
+//! Return value: byte length of the result string written at ptr.
+//! Return 0 or negative to leave the content unchanged.
+//!
+//! - The host provides one import:
+//! `env::log(ptr: i32, len: i32)` — write a log message.
+//!
+//! Plugins receive ONLY plain-text content. Encrypted and image items are
+//! skipped automatically.
use crate::PluginError;
-use std::path::Path;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+use tracing::{info, warn};
+use wasmtime::{Engine, Linker, Module, Store};
+
+// ── Plugin record ─────────────────────────────────────────────────────────────
+
+#[derive(Debug, Clone)]
+pub struct PluginInfo {
+ pub name: String,
+ pub path: PathBuf,
+ pub enabled: bool,
+}
+
+// ── Per-call state threaded through Store ─────────────────────────────────────
+
+struct HostState {
+ plugin_name: String,
+}
+
+// ── Manager ───────────────────────────────────────────────────────────────────
-/// Plugin manager for loading and executing WASM plugins
pub struct PluginManager {
- // TODO: Add WASM runtime
+ engine: Engine,
+ plugins: Arc>>,
}
impl Default for PluginManager {
@@ -15,25 +49,186 @@ impl Default for PluginManager {
}
impl PluginManager {
- /// Create a new plugin manager
pub fn new() -> Self {
- Self {}
+ Self {
+ engine: Engine::default(),
+ plugins: Arc::new(Mutex::new(HashMap::new())),
+ }
}
- /// Load a plugin from a file
- pub async fn load(&self, _path: &Path) -> Result {
- // TODO: Implement plugin loading
- Err(PluginError::LoadFailed("Not implemented".to_string()))
+ /// Load (or reload) a `.wasm` plugin from disk.
+ /// The plugin name is the file stem (e.g. `"dedupe"` for `dedupe.wasm`).
+ pub fn load(&self, path: &Path) -> Result {
+ let name = path
+ .file_stem()
+ .and_then(|s| s.to_str())
+ .ok_or_else(|| PluginError::LoadFailed("Invalid file name".to_string()))?
+ .to_string();
+
+ let module = Module::from_file(&self.engine, path)
+ .map_err(|e| PluginError::LoadFailed(e.to_string()))?;
+
+ let info = PluginInfo {
+ name: name.clone(),
+ path: path.to_path_buf(),
+ enabled: true,
+ };
+
+ self.plugins
+ .lock()
+ .unwrap()
+ .insert(name.clone(), (info, module));
+
+ info!("Plugin loaded: {}", name);
+ Ok(name)
}
- /// Unload a plugin
- pub async fn unload(&self, _name: &str) -> Result<(), PluginError> {
- // TODO: Implement plugin unloading
+ /// Unload a plugin by name.
+ pub fn unload(&self, name: &str) -> Result<(), PluginError> {
+ self.plugins.lock().unwrap().remove(name);
+ info!("Plugin unloaded: {}", name);
Ok(())
}
- /// List loaded plugins
- pub async fn list(&self) -> Result, PluginError> {
- Ok(Vec::new())
+ /// List all loaded plugins.
+ pub fn list(&self) -> Vec {
+ self.plugins
+ .lock()
+ .unwrap()
+ .values()
+ .map(|(info, _)| info.clone())
+ .collect()
+ }
+
+ /// Run all enabled plugins against a text clipboard item.
+ /// Returns the (possibly transformed) content.
+ /// If any plugin errors, it is logged and skipped — the original (or last
+ /// successful) content is passed to the next plugin.
+ pub fn process(&self, content: &str, content_type: &str) -> String {
+ // Only process plain text — skip images, encrypted items, etc.
+ if content_type != "text" && content_type != "code" && content_type != "html" {
+ return content.to_string();
+ }
+
+ let plugins: Vec<(String, Module)> = {
+ let guard = self.plugins.lock().unwrap();
+ guard
+ .values()
+ .filter(|(info, _)| info.enabled)
+ .map(|(info, module)| (info.name.clone(), module.clone()))
+ .collect()
+ };
+
+ let mut current = content.to_string();
+
+ for (name, module) in plugins {
+ match self.run_plugin(&name, &module, ¤t) {
+ Ok(Some(transformed)) => {
+ info!("Plugin '{}' transformed content ({} → {} bytes)", name, current.len(), transformed.len());
+ current = transformed;
+ }
+ Ok(None) => {} // plugin chose not to transform
+ Err(e) => {
+ warn!("Plugin '{}' failed: {}", name, e);
+ }
+ }
+ }
+
+ current
+ }
+
+ // ── Internal: run one plugin ──────────────────────────────────────────────
+
+ fn run_plugin(
+ &self,
+ name: &str,
+ module: &Module,
+ content: &str,
+ ) -> Result, PluginError> {
+ let mut linker: Linker = Linker::new(&self.engine);
+ let plugin_name = name.to_string();
+
+ // Provide `env::log` import
+ // plugin_name is captured by reference via an Arc-like clone so the
+ // closure stays Fn (not FnOnce).
+ let plugin_name_log = plugin_name.to_string();
+ linker
+ .func_wrap(
+ "env",
+ "log",
+ move |mut caller: wasmtime::Caller<'_, HostState>, ptr: i32, len: i32| {
+ let _ = &plugin_name_log; // keep capture alive without moving out
+ if let Some(mem) = caller.get_export("memory") {
+ if let Some(mem) = mem.into_memory() {
+ let data = mem.data(&caller);
+ let ptr = ptr as usize;
+ let len = len as usize;
+ if ptr + len <= data.len() {
+ if let Ok(msg) = std::str::from_utf8(&data[ptr..ptr + len]) {
+ info!("[plugin:{}] {}", caller.data().plugin_name, msg);
+ }
+ }
+ }
+ }
+ },
+ )
+ .map_err(|e| PluginError::ExecutionFailed(e.to_string()))?;
+
+ let mut store = Store::new(
+ &self.engine,
+ HostState {
+ plugin_name: name.to_string(),
+ },
+ );
+
+ let instance = linker
+ .instantiate(&mut store, module)
+ .map_err(|e| PluginError::ExecutionFailed(format!("instantiate: {}", e)))?;
+
+ // Get memory export
+ let memory = instance
+ .get_memory(&mut store, "memory")
+ .ok_or_else(|| PluginError::ExecutionFailed("No memory export".to_string()))?;
+
+ // Get process_item export
+ let process_fn = instance
+ .get_typed_func::<(i32, i32), i32>(&mut store, "process_item")
+ .map_err(|e| PluginError::ExecutionFailed(format!("process_item: {}", e)))?;
+
+ // Write content into guest memory at offset 0
+ let content_bytes = content.as_bytes();
+ if content_bytes.len() > 64 * 1024 {
+ return Err(PluginError::ExecutionFailed(
+ "Content too large for plugin (>64 KB)".to_string(),
+ ));
+ }
+
+ // Grow memory if needed (1 page = 64 KB minimum)
+ let needed_pages = (content_bytes.len() / 65536) + 1;
+ let current_pages = memory.size(&store) as usize;
+ if needed_pages > current_pages {
+ memory
+ .grow(&mut store, (needed_pages - current_pages) as u64)
+ .map_err(|e| PluginError::ExecutionFailed(format!("grow: {}", e)))?;
+ }
+
+ memory
+ .write(&mut store, 0, content_bytes)
+ .map_err(|e| PluginError::ExecutionFailed(format!("write: {}", e)))?;
+
+ let result_len = process_fn
+ .call(&mut store, (0, content_bytes.len() as i32))
+ .map_err(|e| PluginError::ExecutionFailed(format!("call: {}", e)))?;
+
+ if result_len <= 0 {
+ return Ok(None); // no transformation
+ }
+
+ // Read back the result from memory offset 0
+ let result_bytes: Vec = memory.data(&store)[..result_len as usize].to_vec();
+ let result = String::from_utf8(result_bytes)
+ .map_err(|e| PluginError::ExecutionFailed(format!("utf8: {}", e)))?;
+
+ Ok(Some(result))
}
}
diff --git a/crates/clipboard-sync/Cargo.toml b/crates/clipboard-sync/Cargo.toml
index 17ede8a..d32d80d 100644
--- a/crates/clipboard-sync/Cargo.toml
+++ b/crates/clipboard-sync/Cargo.toml
@@ -14,3 +14,8 @@ serde_json = { workspace = true }
thiserror = { workspace = true }
anyhow = { workspace = true }
tracing = { workspace = true }
+reqwest = { version = "0.11", features = ["json"] }
+chrono = { workspace = true }
+clipboard-db = { path = "../clipboard-db" }
+urlencoding = "2.1"
+base64 = "0.22"
diff --git a/crates/clipboard-sync/src/lib.rs b/crates/clipboard-sync/src/lib.rs
index 8552203..e085725 100644
--- a/crates/clipboard-sync/src/lib.rs
+++ b/crates/clipboard-sync/src/lib.rs
@@ -1,10 +1,12 @@
//! OpenPaste Sync Module
//!
-//! This module provides synchronization functionality for clipboard data across devices.
+//! HTTP-based clipboard sync. Each device connects to a shared relay server.
+//! Items are identified by content hash — the server is a simple append-only
+//! log; clients push new items and pull anything newer than their last sync.
pub mod sync;
-pub use sync::SyncManager;
+pub use sync::{SyncClient, SyncConfig, SyncStatus};
use thiserror::Error;
@@ -14,6 +16,10 @@ pub enum SyncError {
SyncFailed(String),
#[error("Provider not configured")]
ProviderNotConfigured,
+ #[error("HTTP error: {0}")]
+ Http(String),
#[error("Conflict detected: {0}")]
ConflictDetected(String),
+ #[error("Database error: {0}")]
+ Database(String),
}
diff --git a/crates/clipboard-sync/src/sync.rs b/crates/clipboard-sync/src/sync.rs
index 2b9952f..c76bc33 100644
--- a/crates/clipboard-sync/src/sync.rs
+++ b/crates/clipboard-sync/src/sync.rs
@@ -1,46 +1,295 @@
-//! Sync manager implementation
+//! Sync client implementation
+//!
+//! Protocol (all JSON over HTTP):
+//!
+//! POST /api/v1/sync/push
+//! Body: { device_id, items: [SyncItem] }
+//! Reply: { accepted: [hash], rejected: [hash] }
+//!
+//! GET /api/v1/sync/pull?device_id=&since=
+//! Reply: { items: [SyncItem] }
+//!
+//! SyncItem mirrors clipboard_items columns except id (server-assigned).
use crate::SyncError;
+use clipboard_db::Database;
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use tracing::{error, info};
-/// Sync manager for clipboard synchronization
-pub struct SyncManager {
- // TODO: Add sync provider configuration
+// ── Wire types ────────────────────────────────────────────────────────────────
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SyncItem {
+ pub hash: String,
+ pub content_type: String,
+ /// Base-64 encoded raw bytes (may be ciphertext when encrypted=true)
+ pub content_b64: String,
+ pub created_at: String,
+ pub pinned: bool,
+ pub favorite: bool,
+ pub encrypted: bool,
+ /// Base-64 encoded nonce, present when encrypted=true
+ pub nonce_b64: Option,
}
-impl Default for SyncManager {
- fn default() -> Self {
- Self::new()
- }
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct PushRequest {
+ device_id: String,
+ items: Vec,
}
-impl SyncManager {
- /// Create a new sync manager
- pub fn new() -> Self {
- Self {}
- }
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct PushResponse {
+ accepted: Vec,
+ #[serde(default)]
+ rejected: Vec,
+}
- /// Start synchronization
- pub async fn start(&self) -> Result<(), SyncError> {
- // TODO: Implement sync start
- Err(SyncError::ProviderNotConfigured)
- }
+#[derive(Debug, Clone, Serialize, Deserialize)]
+struct PullResponse {
+ items: Vec,
+}
- /// Stop synchronization
- pub async fn stop(&self) -> Result<(), SyncError> {
- // TODO: Implement sync stop
- Ok(())
- }
+// ── Config ────────────────────────────────────────────────────────────────────
- /// Get sync status
- pub async fn status(&self) -> Result {
- Ok(SyncStatus::Stopped)
- }
+/// Configuration required to use the sync client.
+#[derive(Debug, Clone)]
+pub struct SyncConfig {
+ /// Base URL of the sync relay server, e.g. `https://sync.example.com`
+ pub server_url: String,
+ /// Stable identifier for this machine (UUID stored in settings)
+ pub device_id: String,
+ /// Optional bearer token for authenticated servers
+ pub api_token: Option,
}
-/// Sync status
+// ── Status ────────────────────────────────────────────────────────────────────
+
#[derive(Debug, Clone, PartialEq)]
pub enum SyncStatus {
- Stopped,
- Running,
+ Idle,
+ Syncing,
Error(String),
}
+
+// ── Client ────────────────────────────────────────────────────────────────────
+
+pub struct SyncClient {
+ config: SyncConfig,
+ http: Client,
+ db: Arc,
+}
+
+impl SyncClient {
+ pub fn new(config: SyncConfig, db: Arc) -> Self {
+ Self {
+ config,
+ http: Client::new(),
+ db,
+ }
+ }
+
+ // ── Push ─────────────────────────────────────────────────────────────────
+
+ /// Push items created after `since_rfc3339` to the server.
+ /// Pass `None` to push everything (initial sync).
+ pub async fn push(&self, since_rfc3339: Option<&str>) -> Result {
+ use base64::{engine::general_purpose::STANDARD, Engine as _};
+
+ // Fetch items from local DB
+ let items = self
+ .db
+ .list_items(1000, 0)
+ .await
+ .map_err(|e| SyncError::Database(e.to_string()))?;
+
+ let to_push: Vec = items
+ .into_iter()
+ .filter(|item| {
+ if let Some(since) = since_rfc3339 {
+ item.created_at.to_rfc3339().as_str() > since
+ } else {
+ true
+ }
+ })
+ .map(|item| SyncItem {
+ hash: item.hash,
+ content_type: item.content_type,
+ content_b64: STANDARD.encode(&item.content),
+ created_at: item.created_at.to_rfc3339(),
+ pinned: item.pinned,
+ favorite: item.favorite,
+ encrypted: item.encrypted,
+ nonce_b64: item.nonce.as_deref().map(|n| STANDARD.encode(n)),
+ })
+ .collect();
+
+ if to_push.is_empty() {
+ return Ok(0);
+ }
+
+ let count = to_push.len();
+ let url = format!("{}/api/v1/sync/push", self.config.server_url);
+
+ let mut req = self
+ .http
+ .post(&url)
+ .json(&PushRequest {
+ device_id: self.config.device_id.clone(),
+ items: to_push,
+ });
+
+ if let Some(ref token) = self.config.api_token {
+ req = req.bearer_auth(token);
+ }
+
+ let resp = req
+ .send()
+ .await
+ .map_err(|e| SyncError::Http(e.to_string()))?;
+
+ if !resp.status().is_success() {
+ let status = resp.status();
+ let body = resp.text().await.unwrap_or_default();
+ return Err(SyncError::Http(format!("{}: {}", status, body)));
+ }
+
+ let push_resp: PushResponse = resp
+ .json()
+ .await
+ .map_err(|e| SyncError::Http(e.to_string()))?;
+
+ info!(
+ "Sync push: {} accepted, {} rejected",
+ push_resp.accepted.len(),
+ push_resp.rejected.len()
+ );
+ Ok(count)
+ }
+
+ // ── Pull ─────────────────────────────────────────────────────────────────
+
+ /// Pull items from the server newer than `since_rfc3339` and insert them
+ /// into the local DB. Already-known hashes (UNIQUE constraint) are silently
+ /// skipped.
+ pub async fn pull(&self, since_rfc3339: Option<&str>) -> Result {
+ use base64::{engine::general_purpose::STANDARD, Engine as _};
+
+ let since_param = since_rfc3339.unwrap_or("1970-01-01T00:00:00Z");
+ let url = format!(
+ "{}/api/v1/sync/pull?device_id={}&since={}",
+ self.config.server_url,
+ urlencoding::encode(&self.config.device_id),
+ urlencoding::encode(since_param)
+ );
+
+ let mut req = self.http.get(&url);
+ if let Some(ref token) = self.config.api_token {
+ req = req.bearer_auth(token);
+ }
+
+ let resp = req
+ .send()
+ .await
+ .map_err(|e| SyncError::Http(e.to_string()))?;
+
+ if !resp.status().is_success() {
+ let status = resp.status();
+ let body = resp.text().await.unwrap_or_default();
+ return Err(SyncError::Http(format!("{}: {}", status, body)));
+ }
+
+ let pull_resp: PullResponse = resp
+ .json()
+ .await
+ .map_err(|e| SyncError::Http(e.to_string()))?;
+
+ let mut inserted = 0usize;
+ for sync_item in pull_resp.items {
+ let content = STANDARD
+ .decode(&sync_item.content_b64)
+ .map_err(|e| SyncError::SyncFailed(format!("base64 decode: {}", e)))?;
+
+ let nonce = sync_item
+ .nonce_b64
+ .as_deref()
+ .and_then(|n| STANDARD.decode(n).ok());
+
+ let created_at = chrono::DateTime::parse_from_rfc3339(&sync_item.created_at)
+ .map_err(|e| SyncError::SyncFailed(format!("date parse: {}", e)))?
+ .with_timezone(&chrono::Utc);
+
+ let db_item = clipboard_db::models::ClipboardItem {
+ id: 0,
+ content_type: sync_item.content_type,
+ content,
+ hash: sync_item.hash,
+ created_at,
+ accessed_at: None,
+ pinned: sync_item.pinned,
+ favorite: sync_item.favorite,
+ nonce,
+ encrypted: sync_item.encrypted,
+ };
+
+ match self.db.insert_item(&db_item).await {
+ Ok(_) => inserted += 1,
+ Err(e) => {
+ // UNIQUE violation = we already have it, not an error
+ if !e.to_string().contains("UNIQUE") {
+ error!("Failed to insert synced item: {}", e);
+ }
+ }
+ }
+ }
+
+ info!("Sync pull: {} new items inserted", inserted);
+ Ok(inserted)
+ }
+
+ // ── Full sync cycle ───────────────────────────────────────────────────────
+
+ /// Run one full push → pull cycle.
+ /// `last_sync` should be persisted to the `settings` table as `last_sync_at`.
+ pub async fn sync_once(&self, last_sync: Option<&str>) -> Result<(usize, usize), SyncError> {
+ let pushed = self.push(last_sync).await?;
+ let pulled = self.pull(last_sync).await?;
+ Ok((pushed, pulled))
+ }
+
+ // ── Background sync loop ──────────────────────────────────────────────────
+
+ /// Spawn a background task that syncs every `interval_secs` seconds.
+ pub fn start_background(client: Arc, interval_secs: u64) {
+ tokio::spawn(async move {
+ let mut ticker =
+ tokio::time::interval(tokio::time::Duration::from_secs(interval_secs));
+
+ loop {
+ ticker.tick().await;
+
+ // Load last sync timestamp from settings
+ let last_sync = client
+ .db
+ .get_setting("last_sync_at")
+ .await
+ .ok()
+ .flatten();
+
+ match client.sync_once(last_sync.as_deref()).await {
+ Ok((pushed, pulled)) => {
+ // Persist new sync timestamp
+ let now = chrono::Utc::now().to_rfc3339();
+ let _ = client.db.upsert_setting("last_sync_at", &now).await;
+ info!("Sync cycle complete: pushed={}, pulled={}", pushed, pulled);
+ }
+ Err(e) => {
+ error!("Sync cycle failed: {}", e);
+ }
+ }
+ }
+ });
+ }
+}
+ {/* Header */}
+
diff --git a/apps/desktop/src/index.css b/apps/desktop/src/index.css
index 6662826..6da3be3 100644
--- a/apps/desktop/src/index.css
+++ b/apps/desktop/src/index.css
@@ -16,3 +16,12 @@ body, html {
overflow: hidden;
background-color: #171A1F;
}
+
+.shortcuts-hint:hover .shortcuts-tooltip {
+ display: flex !important;
+}
+
+@keyframes spin {
+ from { transform: rotate(0deg); }
+ to { transform: rotate(360deg); }
+}
diff --git a/crates/clipboard-api/Cargo.toml b/crates/clipboard-api/Cargo.toml
index ccc6728..5e62d4f 100644
--- a/crates/clipboard-api/Cargo.toml
+++ b/crates/clipboard-api/Cargo.toml
@@ -7,6 +7,10 @@ authors.workspace = true
license.workspace = true
repository.workspace = true
+[[bin]]
+name = "clipboard-api"
+path = "src/main.rs"
+
[dependencies]
tokio = { workspace = true }
serde = { workspace = true }
@@ -14,8 +18,13 @@ serde_json = { workspace = true }
thiserror = { workspace = true }
anyhow = { workspace = true }
tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
axum = { workspace = true }
tower-http = { version = "0.5", features = ["cors", "trace"] }
clipboard-core = { path = "../clipboard-core" }
clipboard-db = { path = "../clipboard-db" }
clipboard-search = { path = "../clipboard-search" }
+chrono = { workspace = true }
+base64 = "0.22"
+md5 = "0.7"
+dirs = "5.0"
diff --git a/crates/clipboard-api/src/api.rs b/crates/clipboard-api/src/api.rs
index f62c852..0547b58 100644
--- a/crates/clipboard-api/src/api.rs
+++ b/crates/clipboard-api/src/api.rs
@@ -1,77 +1,317 @@
-//! REST API server implementation
+//! REST API server
+//!
+//! Routes:
+//! GET /api/v1/status — health check
+//! GET /api/v1/clipboard — get current clipboard content
+//! POST /api/v1/clipboard — set clipboard content
+//! POST /api/v1/search — FTS5 search
+//! GET /api/v1/history — list history (limit/offset)
+//! GET /api/v1/item/:id — get single item
+//! DELETE /api/v1/item/:id — delete item
+//! POST /api/v1/sync/push — sync push endpoint
+//! GET /api/v1/sync/pull — sync pull endpoint
use crate::ApiError;
use axum::{
+ extract::{Path, Query, State},
routing::{get, post},
- Router,
+ Json, Router,
};
+use clipboard_db::Database;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
use std::net::SocketAddr;
+use std::sync::Arc;
use tokio::net::TcpListener;
+use tower_http::cors::CorsLayer;
+
+// ── Shared app state ──────────────────────────────────────────────────────────
+
+#[derive(Clone)]
+pub struct AppState {
+ pub db: Arc
+
+
+
+ {syncConfig.enabled
+ ?
+
+ + Sync +
++ Sync your clipboard history across devices via a self-hosted relay server + (or any server running the OpenPaste HTTP API). +
+ + {/* Status banners */} + {syncError && ( +
+ {syncError}
+
+ )}
+ {syncStatus && (
+
+
+ )}
+
+ {/* Form */}
+
+
+ {/* Enable toggle */}
+
+ Enable sync
+
+
+ {/* Server URL */}
+ setSyncConfig(c => ({ ...c, enabled: !c.enabled }))}
+ style={{
+ width: '44px', height: '24px',
+ backgroundColor: syncConfig.enabled ? '#6D7FFF' : '#3A414C',
+ borderRadius: '12px', position: 'relative', cursor: 'pointer',
+ transition: 'background-color 0.2s',
+ }}
+ >
+
+
+
+
+ setSyncConfig(c => ({ ...c, server_url: e.target.value }))}
+ style={{
+ width: '100%', padding: '9px 12px', boxSizing: 'border-box',
+ backgroundColor: '#1F242B', border: '1px solid #3A414C',
+ borderRadius: '7px', color: '#F3F5F8', fontSize: '14px', outline: 'none',
+ }}
+ />
+
+
+ {/* API token */}
+
+
+ setSyncConfig(c => ({ ...c, api_token: e.target.value || null }))}
+ style={{
+ width: '100%', padding: '9px 12px', boxSizing: 'border-box',
+ backgroundColor: '#1F242B', border: '1px solid #3A414C',
+ borderRadius: '7px', color: '#F3F5F8', fontSize: '14px', outline: 'none',
+ }}
+ />
+
+
+ {/* Last sync */}
+ {syncConfig.last_sync_at && (
+
+
+ )}
+
+ {/* Buttons */}
+
+
+