feat: implement all 7 specs — capture engine, editor, history, OCR, sharing, recording, settings

Spec 01 - Capture Engine: add delay, current screen, last region modes;
return rich CaptureResult metadata from all capture commands.

Spec 02 - Editor: Fabric.js-based annotation editor with 11 tools
(arrow, rect, ellipse, line, freehand, highlight, text, step numbers,
blur, pixelate), style system, undo/redo, export.

Spec 03 - History & Workflow: history metadata API with search, bulk
delete; workflow rule engine with conditions and action chains.

Spec 04 - OCR & Privacy: macOS Vision framework OCR (en/zh/ja/ko);
regex-based sensitive info detection (email, phone, API key, JWT, IP).

Spec 05 - Sharing & Export: image format conversion (PNG/JPG/WebP),
image info metadata, clipboard improvements.

Spec 06 - Recording: start/stop screen recording via macOS screencapture,
ffmpeg-based GIF conversion, thread-safe recording state.

Spec 07 - Settings & Platform: capture settings, shortcut editor with
record-and-set UI, history retention, platform capability detection,
diagnostics bundle.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: JunaYa

package.json

@@ -24,6 +24,7 @@
     "@tauri-apps/plugin-store": "^2.4.3",
     "@tauri-apps/plugin-window-state": "^2.4.1",
     "@vueuse/core": "^14.3.0",
+    "fabric": "^6.9.1",
     "vue": "^3.5.34"
   },
   "devDependencies": {

pnpm-lock.yaml

@@ -49,6 +49,8 @@ core-foundation = "0.10"
 libc = "0.2"
 base64 = "0.22"
 image_compressor = "1.5"
+regex-lite = "0.1"
+os_info = "3"
 
 [features]
 default = [ "custom-protocol" ]

src-tauri/Cargo.lock

@@ -0,0 +1,145 @@
+use serde::{Deserialize, Serialize};
+use tracing::info;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PlatformCapability {
+    pub key: String,
+    pub status: String,
+    pub reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DiagnosticsBundle {
+    pub app_version: String,
+    pub os: String,
+    pub os_version: String,
+    pub arch: String,
+    pub capabilities: Vec<PlatformCapability>,
+    pub permissions: Vec<PlatformCapability>,
+}
+
+#[tauri::command]
+pub fn get_platform_capabilities() -> Vec<PlatformCapability> {
+    let mut caps = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+        caps.push(PlatformCapability {
+            key: "regionCapture".to_string(),
+            status: "available".to_string(),
+            reason: None,
+        });
+        caps.push(PlatformCapability {
+            key: "windowCapture".to_string(),
+            status: "available".to_string(),
+            reason: None,
+        });
+        caps.push(PlatformCapability {
+            key: "fullScreenCapture".to_string(),
+            status: "available".to_string(),
+            reason: None,
+        });
+        caps.push(PlatformCapability {
+            key: "screenRecording".to_string(),
+            status: "available".to_string(),
+            reason: None,
+        });
+        caps.push(PlatformCapability {
+            key: "globalShortcuts".to_string(),
+            status: "available".to_string(),
+            reason: None,
+        });
+        caps.push(PlatformCapability {
+            key: "ocr".to_string(),
+            status: "available".to_string(),
+            reason: Some("macOS Vision framework".to_string()),
+        });
+        caps.push(PlatformCapability {
+            key: "systemAudio".to_string(),
+            status: "limited".to_string(),
+            reason: Some("Requires additional setup on macOS".to_string()),
+        });
+        caps.push(PlatformCapability {
+            key: "scrollingCapture".to_string(),
+            status: "unavailable".to_string(),
+            reason: Some("Not yet implemented".to_string()),
+        });
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        let is_wayland = std::env::var("WAYLAND_DISPLAY").is_ok();
+        let desktop = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default();
+
+        caps.push(PlatformCapability {
+            key: "regionCapture".to_string(),
+            status: if is_wayland { "limited" } else { "available" }.to_string(),
+            reason: if is_wayland { Some("Uses xdg-desktop-portal on Wayland".to_string()) } else { None },
+        });
+        caps.push(PlatformCapability {
+            key: "globalShortcuts".to_string(),
+            status: if is_wayland { "unavailable" } else { "available" }.to_string(),
+            reason: if is_wayland { Some("Wayland restricts global shortcuts".to_string()) } else { None },
+        });
+        caps.push(PlatformCapability {
+            key: "desktopEnvironment".to_string(),
+            status: "available".to_string(),
+            reason: Some(desktop),
+        });
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        caps.push(PlatformCapability {
+            key: "regionCapture".to_string(),
+            status: "available".to_string(),
+            reason: None,
+        });
+        caps.push(PlatformCapability {
+            key: "globalShortcuts".to_string(),
+            status: "available".to_string(),
+            reason: None,
+        });
+    }
+
+    caps
+}
+
+#[tauri::command]
+pub fn get_diagnostics_bundle(app_handle: tauri::AppHandle) -> DiagnosticsBundle {
+    let version = app_handle.config().version.clone().unwrap_or_else(|| "unknown".to_string());
+
+    DiagnosticsBundle {
+        app_version: version,
+        os: std::env::consts::OS.to_string(),
+        os_version: os_info::get().version().to_string(),
+        arch: std::env::consts::ARCH.to_string(),
+        capabilities: get_platform_capabilities(),
+        permissions: get_permission_status(),
+    }
+}
+
+fn get_permission_status() -> Vec<PlatformCapability> {
+    let mut perms = Vec::new();
+
+    #[cfg(target_os = "macos")]
+    {
+        let has_accessibility = crate::platform::check_accessibility_permissions();
+        perms.push(PlatformCapability {
+            key: "accessibility".to_string(),
+            status: if has_accessibility { "available" } else { "unavailable" }.to_string(),
+            reason: if !has_accessibility {
+                Some("Grant in System Settings > Privacy > Accessibility".to_string())
+            } else {
+                None
+            },
+        });
+        perms.push(PlatformCapability {
+            key: "screenRecording".to_string(),
+            status: "unknown".to_string(),
+            reason: Some("Check System Settings > Privacy > Screen Recording".to_string()),
+        });
+    }
+
+    perms
+}

src-tauri/Cargo.toml

@@ -0,0 +1,83 @@
+use std::path::Path;
+use image::ImageReader;
+use serde::{Deserialize, Serialize};
+use tracing::info;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExportOptions {
+    pub format: String,
+    pub quality: u8,
+}
+
+#[tauri::command]
+pub async fn export_image(
+    source_path: String,
+    target_path: String,
+    format: String,
+    quality: u8,
+) -> Result<String, String> {
+    let source = Path::new(&source_path);
+    if !source.exists() {
+        return Err("Source file not found".to_string());
+    }
+
+    let img = ImageReader::open(source)
+        .map_err(|e| e.to_string())?
+        .decode()
+        .map_err(|e| e.to_string())?;
+
+    let target = Path::new(&target_path);
+    if let Some(parent) = target.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+
+    match format.as_str() {
+        "png" => {
+            img.save_with_format(target, image::ImageFormat::Png)
+                .map_err(|e| e.to_string())?;
+        }
+        "jpg" | "jpeg" => {
+            let mut buf = std::io::BufWriter::new(
+                std::fs::File::create(target).map_err(|e| e.to_string())?,
+            );
+            let encoder = image::codecs::jpeg::JpegEncoder::new_with_quality(&mut buf, quality);
+            img.write_with_encoder(encoder).map_err(|e| e.to_string())?;
+        }
+        "webp" => {
+            img.save_with_format(target, image::ImageFormat::WebP)
+                .map_err(|e| e.to_string())?;
+        }
+        _ => {
+            return Err(format!("Unsupported format: {}", format));
+        }
+    }
+
+    info!("Exported image to {} as {}", target_path, format);
+    Ok(target_path)
+}
+
+#[tauri::command]
+pub fn get_image_info(path: String) -> Result<ImageInfo, String> {
+    let p = Path::new(&path);
+    if !p.exists() {
+        return Err("File not found".to_string());
+    }
+    let metadata = std::fs::metadata(p).map_err(|e| e.to_string())?;
+    let (width, height) = image::image_dimensions(p).unwrap_or((0, 0));
+    let ext = p.extension().and_then(|e| e.to_str()).unwrap_or("").to_string();
+
+    Ok(ImageInfo {
+        width,
+        height,
+        file_size: metadata.len(),
+        format: ext,
+    })
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ImageInfo {
+    pub width: u32,
+    pub height: u32,
+    pub file_size: u64,
+    pub format: String,
+}