feat: add backup and restore functionality with encryption options

- Implemented BackupSection component for managing backup packages.
- Added functionality to export and import data in CSV and JSON formats.
- Introduced options for encrypted backups with passphrase support.
- Enhanced user experience with validation and preview of backup packages.
- Updated WidgetCenter to handle new 'coming soon' feature for official widgets.
- Added legacy data detection and import functions in the Tauri API.
- Defined LegacyDataInfo type in the types module for better type safety.

Author: PythonSmall-Q

CHANGELOG.md

@@ -5,7 +5,7 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ---
 
-## [2.0.0] - 2026-06-12
+## [2.0.0] - 2026-07-17
 
 ### Added
 
@@ -45,6 +45,9 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - **Local API server governance** — hardened all API server routes to enforce widget-scoped API token scopes and reject unscoped or revoked tokens.
 - **Offline test harness scripts** — added `scripts/offline-journey-tests.sh` and `scripts/migration-rehearsal.sh` for local critical-journey and migration validation.
 - **VS Code extension sidebar home page redesign** — added connection status badge, focus-mode indicator, today's VS Code time card, language/project breakdown with progress bars, top desktop apps, and cleaner action buttons; sidebar API calls now include `X-Api-Token` and `X-Client-Id` headers for local API governance compatibility.
+- **Legacy 1.x data import prompt** — when the default profile is empty and a legacy 1.x database (e.g. upgraded from 1.4.4) is detected, Settings now shows a one-time dialog asking whether to import the existing data. An "Import legacy data" button is also shown below the current profile card.
+- **Backend commands for legacy data import** — added `detect_legacy_data` and `import_legacy_data` commands to support the new import flow.
+
 
 ### Changed
 
@@ -71,9 +74,16 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 - **`getProjectDisplayName` helper** in `src/utils/format.ts` with unit tests: prefers `project_name`, falls back to the basename of `project_path`, and finally returns the localized `dashboard:unknownProject` label.
 - **`dashboard:unknownProject`** i18n key across all desktop locales (`en`, `zh-CN`, `zh-TW`, `ja`, `ko`, `fr`, `de`, `es`).
 - **`unknownProject`** runtime string to the VS Code extension i18n module, used by the extension dashboard panel when a project name is missing.
+- **Profile switching UI entry removed** — the profile switch buttons in Settings > Profiles are no longer shown. The `switch_profile` backend command remains available for API/internal use.
+- **Legacy data migration is now user-confirmed** — startup no longer silently imports legacy 1.x data into the default profile. Importing now requires explicit confirmation via the new prompt or button, and is applied on the next restart through a pending-import flag.
+- **Desktop pet widget temporarily disabled** — the pet widget is marked as “Coming Soon ” in the Widget Center; its title, description, and add button are grayed out and disabled. A backend guard in `create_widget` also rejects `widget_type == "pet"` to prevent creation through any path.
+- **Profile creation button disabled** — the “Create profile” button in Settings > Profiles is temporarily disabled and the creation dialog is hidden.
 
 ### Fixed
 
+- **Backup & Restore UI/UX** — rewrote the Settings page into a clear export/import card layout, added explicit file-selection feedback, a step-by-step validate-then-restore flow, and native notifications on success.
+- **Restore feedback** — restoring a backup now shows a clear status message instead of failing silently; encrypted backups correctly prompt for the passphrase before applying.
+- **Native confirmation dialogs in Settings** — replaced `window.confirm` with `@tauri-apps/plugin-dialog` `confirm()` to prevent `dialog.confirm not allowed` errors in the Tauri webview.
 - **Settings excluded apps could not be unchecked after saving** — fixed a path-normalization mismatch: the backend stores ignored app paths lowercased, but the frontend compared original-case paths, causing excluded apps to vanish from the list. The list now renders ignored apps directly with case-insensitive matching so they remain visible and togglable.
 - **VS Code extension sidebar title showed raw `%timelens.homeView.name%`** — fixed invalid JSON in `vscode-extension/package.nls.json` and `vscode-extension/package.nls.zh-CN.json` (missing comma after `timelens.apiToken.description`), which prevented VS Code from resolving all `%...%` placeholder strings in `package.json`.
 - **Profile switching reliability** — fixed a bug where switching profiles could result in a "connection refused" error or missing profiles because `current_profile_id` was stored inside the encrypted profile database.

src-tauri/src/commands/data_reliability_cmd.rs

@@ -6,7 +6,7 @@ use chrono::{Duration, Local, NaiveDate};
 use rusqlite::params;
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
-use tauri::{Manager, State};
+use tauri::{AppHandle, Manager, State};
 use zip::{write::FileOptions, CompressionMethod, ZipArchive, ZipWriter};
 
 use crate::commands::storage_cmd::DbState;
@@ -2501,6 +2501,67 @@ pub fn create_profile(
     })
 }
 
+#[derive(Debug, Serialize)]
+pub struct LegacyDataInfo {
+    pub available: bool,
+    pub source_path: Option<String>,
+    pub default_profile_empty: bool,
+    pub current_profile_is_default: bool,
+    pub can_import: bool,
+}
+
+#[tauri::command]
+pub fn detect_legacy_data(app: AppHandle) -> Result<LegacyDataInfo, String> {
+    let data_dir = app.path().app_data_dir().map_err(|e| e.to_string())?;
+    let app_state_conn = db::migrations::open_app_state_db(&data_dir)
+        .map_err(|e| format!("Failed to open app state database: {}", e))?;
+    let current_profile_id = db::migrations::current_profile_id_from_app_state(&app_state_conn);
+
+    let default_db = db::migrations::db_path_for_profile(
+        &data_dir,
+        db::migrations::DEFAULT_PROFILE_ID,
+    );
+    let default_profile_empty = if default_db.exists() {
+        match db::open(&default_db) {
+            Ok(conn) => {
+                let count: i64 = conn
+                    .query_row("SELECT COUNT(1) FROM app_usage", [], |r| r.get(0))
+                    .unwrap_or(0);
+                count == 0
+            }
+            Err(_) => {
+                // If we cannot open the default profile (e.g. it is encrypted),
+                // treat it as non-empty so we do not risk overwriting data.
+                false
+            }
+        }
+    } else {
+        true
+    };
+
+    let legacy = crate::legacy_db_path();
+    let current_profile_is_default = current_profile_id == db::migrations::DEFAULT_PROFILE_ID;
+    Ok(LegacyDataInfo {
+        available: legacy.is_some(),
+        source_path: legacy.as_ref().map(|p| p.to_string_lossy().to_string()),
+        default_profile_empty,
+        current_profile_is_default,
+        can_import: legacy.is_some() && default_profile_empty && current_profile_is_default,
+    })
+}
+
+#[tauri::command]
+pub fn import_legacy_data(app: AppHandle) -> Result<(), String> {
+    let data_dir = app.path().app_data_dir().map_err(|e| e.to_string())?;
+    let conn = db::migrations::open_app_state_db(&data_dir)
+        .map_err(|e| e.to_string())?;
+    db::set_setting(&conn, crate::PENDING_LEGACY_IMPORT_KEY, "1")
+        .map_err(|e| e.to_string())?;
+    log::info!("User requested legacy data import; restarting to apply");
+    app.restart();
+}
+
+
 #[tauri::command]
 pub fn switch_profile(
     profile_id: String,

src-tauri/src/commands/widget_cmd.rs

@@ -215,6 +215,9 @@ pub async fn create_widget(
     app: AppHandle,
     db: tauri::State<'_, DbState>,
 ) -> Result<WidgetConfig, String> {
+    if widget_type == "pet" {
+        return Err("Desktop pet widget is under development. Stay tuned.".to_string());
+    }
     let id = format!("{}-{}", widget_type, short_id());
     let (width, height) = default_size(&app, &widget_type)?;
 

src-tauri/src/lib.rs

@@ -94,6 +94,7 @@ fn format_seconds(secs: i64) -> String {
 
 const LEGACY_APP_DIR_NAME: &str = "ShanWenxiao.TimeLens-TimeManagementAppwithWidgets";
 const DEFAULT_PROFILE_ID: &str = "default";
+pub(crate) const PENDING_LEGACY_IMPORT_KEY: &str = "pending_legacy_import";
 
 fn copy_if_exists(src: &Path, dst: &Path) -> std::io::Result<()> {
     if src.exists() {
@@ -156,7 +157,7 @@ fn copy_db_with_sidecars(src: &Path, dst: &Path) -> std::io::Result<()> {
 /// Best-effort detection of a legacy 1.x database path on all supported
 /// platforms. Tauri v1 placed app data differently than v2; this function
 /// probes the most likely locations without requiring Tauri APIs.
-fn legacy_db_path() -> Option<PathBuf> {
+pub(crate) fn legacy_db_path() -> Option<PathBuf> {
     #[cfg(target_os = "windows")]
     {
         let appdata = std::env::var_os("APPDATA")?;
@@ -208,43 +209,62 @@ fn migrate_legacy_db(legacy_db: &Path, target_db: &Path) -> std::io::Result<()>
 
 fn resolve_database_path(data_dir: &Path, profile_id: Option<&str>) -> PathBuf {
     let profile_id = profile_id.unwrap_or(DEFAULT_PROFILE_ID);
-    let target_db = db_path_for_profile(data_dir, profile_id);
-
-    // Only the default profile attempts to auto-migrate from legacy 1.x paths.
-    if profile_id == DEFAULT_PROFILE_ID {
-        if let Some(legacy_path) = legacy_db_path() {
-            let current_size = std::fs::metadata(&target_db).map(|m| m.len()).unwrap_or(0);
-            let legacy_size = std::fs::metadata(&legacy_path)
-                .map(|m| m.len())
-                .unwrap_or(0);
-
-            let should_migrate =
-                !target_db.exists() || (current_size <= 4096 && legacy_size > current_size);
-
-            if should_migrate {
-                match migrate_legacy_db(&legacy_path, &target_db) {
-                    Ok(()) => {
-                        log::info!(
-                            "TimeLens DB migrated from legacy path to profile path: {} -> {}",
-                            legacy_path.display(),
-                            target_db.display()
-                        );
-                    }
-                    Err(err) => {
-                        log::warn!(
-                            "TimeLens DB migration failed ({} -> {}): {}. Falling back to legacy DB path.",
-                            legacy_path.display(),
-                            target_db.display(),
-                            err
-                        );
-                        return legacy_path;
-                    }
-                }
-            }
-        }
+    db_path_for_profile(data_dir, profile_id)
+}
+
+/// Apply a pending user-approved legacy import before any profile database is
+/// opened. This is invoked once per restart after the frontend confirms the
+/// import; it copies the legacy 1.x database into the default profile and
+/// leaves the flag cleared so the prompt does not repeat.
+fn maybe_apply_pending_legacy_import(
+    app_state_conn: &rusqlite::Connection,
+    data_dir: &Path,
+) -> Result<(), String> {
+    let pending = db::get_setting(app_state_conn, PENDING_LEGACY_IMPORT_KEY)
+        .ok()
+        .flatten()
+        .unwrap_or_default()
+        == "1";
+    if !pending {
+        return Ok(());
     }
 
-    target_db
+    // Clear the flag immediately so a failed import does not loop on restart.
+    let _ = db::set_setting(app_state_conn, PENDING_LEGACY_IMPORT_KEY, "0");
+
+    let current_profile_id = db::migrations::current_profile_id_from_app_state(app_state_conn);
+    if current_profile_id != db::migrations::DEFAULT_PROFILE_ID {
+        log::info!("Pending legacy import ignored: current profile is not default");
+        return Ok(());
+    }
+
+    let Some(legacy_path) = legacy_db_path() else {
+        log::info!("Pending legacy import ignored: no legacy database found");
+        return Ok(());
+    };
+
+    let target_db = db::migrations::db_path_for_profile(data_dir, db::migrations::DEFAULT_PROFILE_ID);
+    let target_size = std::fs::metadata(&target_db).map(|m| m.len()).unwrap_or(0);
+    if target_size > 4096 {
+        log::info!("Pending legacy import ignored: default profile already contains data");
+        return Ok(());
+    }
+
+    // Remove any existing empty/small default profile database so the copy is clean.
+    let _ = std::fs::remove_file(&target_db);
+    let _ = std::fs::remove_file(format!("{}-wal", target_db.display()));
+    let _ = std::fs::remove_file(format!("{}-shm", target_db.display()));
+
+    migrate_legacy_db(&legacy_path, &target_db).map_err(|e| {
+        format!("Failed to import legacy data into default profile: {}", e)
+    })?;
+
+    log::info!(
+        "TimeLens legacy database imported into default profile: {} -> {}",
+        legacy_path.display(),
+        target_db.display()
+    );
+    Ok(())
 }
 
 fn init_file_logger(log_dir: &Path) -> Result<(), String> {
@@ -491,15 +511,19 @@ pub fn run() {
             let data_dir = app.path().app_data_dir()?;
             std::fs::create_dir_all(&data_dir)?;
 
-            // Compute the default profile path first so legacy migration can run
-            // before we read global profile state.
-            let default_db_path = resolve_database_path(&data_dir, None);
-
             // Open the unencrypted app state database first (before any profile DB)
             // so profile metadata is available even when profile DBs are encrypted.
             let app_state_conn = db::migrations::open_app_state_db(&data_dir)
                 .map_err(|e| format!("Failed to open app state database: {}", e))?;
 
+            // Apply any user-approved legacy 1.x import before we resolve the default
+            // profile path so the imported database is used on this startup.
+            if let Err(e) = maybe_apply_pending_legacy_import(&app_state_conn, &data_dir) {
+                log::warn!("Failed to apply pending legacy import: {}", e);
+            }
+
+            let default_db_path = resolve_database_path(&data_dir, None);
+
             // One-time migration of profile metadata from the legacy default
             // profile DB into the separate app state DB.
             let _ = db::migrations::migrate_profile_state_from_default_db(
@@ -946,6 +970,8 @@ pub fn run() {
             commands::create_profile,
             commands::switch_profile,
             commands::get_current_profile,
+            commands::detect_legacy_data,
+            commands::import_legacy_data,
             commands::repair_data_issues,
             commands::export_backup_v2,
             commands::import_backup_v2_validate,