feat: Add automatic migration from amazon-q to kiro-cli (#3359)

* feat: Add automatic migration from amazon-q to kiro-cli

- Migrate database from {data_local_dir}/amazon-q to {data_local_dir}/kiro-cli
- Migrate settings from {data_local_dir}/amazon-q to ~/.aws/kiro-cli
- Transform api.q.service → api.kiro.service in settings
- Add migration.kiro.completed flag to track completion
- Implement file locking with rustix to prevent race conditions
- Run migration automatically on CLI startup (silent, no user interaction)
- Add hidden 'migrate' subcommand for manual migration
- Update paths.rs to use new locations with fallback to old

* Address comments

Author: kkashilk

Cargo.lock

@@ -87,6 +87,7 @@ regex = "1.7.0"
 reqwest = { version = "0.12.14", default-features = false, features = ["http2", "charset", "rustls-tls", "rustls-tls-native-roots", "gzip", "json", "socks", "cookies", "stream"] }
 ring = "0.17.14"
 rusqlite = { version = "0.32.1", features = ["bundled", "serde_json"] }
+rustix = { version = "1.1.2", features = ["fs"] }
 rustls = "0.23.23"
 rustls-native-certs = "0.8.1"
 rustls-pemfile = "2.1.0"

Cargo.toml

@@ -80,6 +80,7 @@ regex.workspace = true
 reqwest.workspace = true
 ring.workspace = true
 rusqlite.workspace = true
+rustix.workspace = true
 rustls.workspace = true
 rustls-native-certs.workspace = true
 rustls-pemfile.workspace = true

crates/chat-cli/Cargo.toml

@@ -0,0 +1,328 @@
+use std::path::{
+    Path,
+    PathBuf,
+};
+use std::process::ExitCode;
+
+use clap::Parser;
+use eyre::{
+    Context,
+    Result,
+};
+use rustix::fs::{
+    FlockOperation,
+    flock,
+};
+use serde_json::{
+    Map,
+    Value,
+};
+use tokio::fs;
+
+use crate::os::Os;
+use crate::util::paths::GlobalPaths;
+
+#[derive(Debug, Parser, PartialEq)]
+pub struct MigrateArgs {
+    /// Force migration even if already completed
+    #[arg(long)]
+    pub force: bool,
+
+    /// Dry run - show what would be migrated
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Skip confirmation prompts
+    #[arg(long, short = 'y')]
+    pub yes: bool,
+}
+
+impl MigrateArgs {
+    pub async fn execute(self, os: &mut Os) -> Result<ExitCode> {
+        // Try to acquire migration lock
+        let _lock = match acquire_migration_lock()? {
+            Some(lock) => lock,
+            None => {
+                println!("Migration already in progress by another process");
+                return Ok(ExitCode::SUCCESS);
+            },
+        };
+
+        let status = detect_migration(os).await?;
+
+        if !self.force && matches!(status, MigrationStatus::Completed) {
+            println!("✓ Migration already completed");
+            return Ok(ExitCode::SUCCESS);
+        }
+
+        let MigrationStatus::Needed {
+            old_db,
+            old_settings,
+            new_db,
+            new_settings,
+        } = status
+        else {
+            println!("✓ No migration needed (fresh install)");
+            return Ok(ExitCode::SUCCESS);
+        };
+
+        if !self.yes && !self.dry_run {
+            println!("This will migrate your database and settings from amazon-q to kiro-cli.");
+            println!("\nMigration details:");
+            println!("  • Database: {{data_local_dir}}/amazon-q → {{data_local_dir}}/kiro-cli");
+            println!("  • Settings: {{data_local_dir}}/amazon-q → ~/.aws/kiro-cli");
+            println!("\nContinue? (y/N)");
+
+            let mut input = String::new();
+            std::io::stdin().read_line(&mut input)?;
+            if !input.trim().eq_ignore_ascii_case("y") {
+                println!("Migration cancelled");
+                return Ok(ExitCode::SUCCESS);
+            }
+        }
+
+        // Migrate database
+        let db_result = migrate_database(&old_db, &new_db, self.dry_run).await?;
+        println!("✓ Database: {}", db_result.message);
+
+        // Reload database connection after copying the file
+        if !self.dry_run && db_result.bytes_copied > 0 {
+            os.database = crate::database::Database::new().await?;
+        }
+
+        // Migrate settings
+        let settings_result = migrate_settings(&old_settings, &new_settings, self.dry_run).await?;
+        println!("✓ Settings: {}", settings_result.message);
+        if !settings_result.transformations.is_empty() {
+            println!("  Transformations applied:");
+            for t in &settings_result.transformations {
+                println!("    - {t}");
+            }
+        }
+
+        if !self.dry_run {
+            os.database.set_kiro_migration_completed()?;
+            println!("\n✓ Migration completed successfully!");
+        } else {
+            println!("\n(Dry run - no changes made)");
+        }
+
+        Ok(ExitCode::SUCCESS)
+    }
+}
+
+// Migration detection
+#[derive(Debug)]
+enum MigrationStatus {
+    NotNeeded,
+    Needed {
+        old_db: PathBuf,
+        old_settings: PathBuf,
+        new_db: PathBuf,
+        new_settings: PathBuf,
+    },
+    Completed,
+}
+
+async fn detect_migration(os: &mut Os) -> Result<MigrationStatus> {
+    let old_db = GlobalPaths::old_database_path()?;
+    let old_settings = GlobalPaths::old_settings_path()?;
+    let new_db = GlobalPaths::database_path()?;
+    let new_settings = GlobalPaths::settings_path()?;
+
+    let old_exists = old_db.exists() || old_settings.exists();
+    let migration_completed = os.database.is_kiro_migration_completed().unwrap_or(false);
+
+    if migration_completed {
+        Ok(MigrationStatus::Completed)
+    } else if old_exists {
+        Ok(MigrationStatus::Needed {
+            old_db,
+            old_settings,
+            new_db,
+            new_settings,
+        })
+    } else {
+        Ok(MigrationStatus::NotNeeded)
+    }
+}
+
+// Database migration
+#[derive(Debug)]
+struct DbMigrationResult {
+    message: String,
+    #[allow(dead_code)]
+    bytes_copied: u64,
+}
+
+async fn migrate_database(old_path: &Path, new_path: &Path, dry_run: bool) -> Result<DbMigrationResult> {
+    if !old_path.exists() {
+        return Ok(DbMigrationResult {
+            message: "No database to migrate".to_string(),
+            bytes_copied: 0,
+        });
+    }
+
+    let metadata = fs::metadata(old_path).await.context("Cannot read source database")?;
+    if !metadata.is_file() {
+        eyre::bail!("Database is not a file");
+    }
+    if metadata.len() == 0 {
+        eyre::bail!("Database is empty");
+    }
+
+    if dry_run {
+        return Ok(DbMigrationResult {
+            message: format!(
+                "Would copy database:\n  From: {}\n  To: {}",
+                old_path.display(),
+                new_path.display()
+            ),
+            bytes_copied: 0,
+        });
+    }
+
+    if let Some(parent) = new_path.parent() {
+        fs::create_dir_all(parent)
+            .await
+            .context(format!("Failed to create target directory: {}", parent.display()))?;
+    }
+
+    let bytes = fs::copy(old_path, new_path).await.context("Failed to copy database")?;
+
+    let metadata = fs::metadata(new_path).await.context("Cannot read migrated database")?;
+    if metadata.len() == 0 {
+        eyre::bail!("Migrated database is empty");
+    }
+
+    Ok(DbMigrationResult {
+        message: format!("Migrated database ({bytes} bytes)"),
+        bytes_copied: bytes,
+    })
+}
+
+// Settings migration
+#[derive(Debug)]
+struct SettingsMigrationResult {
+    message: String,
+    #[allow(dead_code)]
+    settings_count: usize,
+    transformations: Vec<String>,
+}
+
+async fn migrate_settings(old_path: &Path, new_path: &Path, dry_run: bool) -> Result<SettingsMigrationResult> {
+    let settings = if old_path.exists() {
+        let content = fs::read_to_string(old_path)
+            .await
+            .context("Failed to read settings file")?;
+        let value: Value = serde_json::from_str(&content).context("Failed to parse settings JSON")?;
+        match value {
+            Value::Object(map) => map,
+            _ => Map::new(),
+        }
+    } else {
+        Map::new()
+    };
+
+    let mut transformed = settings;
+    let mut transformations = Vec::new();
+
+    // Transform api.q.service → api.kiro.service
+    if let Some(q_service) = transformed.remove("api.q.service") {
+        transformed.insert("api.kiro.service".to_string(), q_service);
+        transformations.push("api.q.service → api.kiro.service".to_string());
+    }
+
+    // Add migration completed flag
+    transformed.insert("migration.kiro.completed".to_string(), Value::Bool(true));
+    transformations.push("Added migration.kiro.completed flag".to_string());
+
+    if dry_run {
+        return Ok(SettingsMigrationResult {
+            message: format!(
+                "Would migrate settings:\n  From: {}\n  To: {}\n  Transformations: {}",
+                old_path.display(),
+                new_path.display(),
+                transformations.join(", ")
+            ),
+            settings_count: transformed.len(),
+            transformations,
+        });
+    }
+
+    if let Some(parent) = new_path.parent() {
+        fs::create_dir_all(parent)
+            .await
+            .context(format!("Failed to create target directory: {}", parent.display()))?;
+    }
+
+    let json = serde_json::to_string_pretty(&transformed).context("Failed to serialize settings")?;
+    fs::write(new_path, json)
+        .await
+        .context("Failed to write settings file")?;
+
+    Ok(SettingsMigrationResult {
+        message: "Settings migrated successfully".to_string(),
+        settings_count: transformed.len(),
+        transformations,
+    })
+}
+
+// File locking
+struct MigrationLock {
+    _file: std::fs::File,
+    path: PathBuf,
+}
+
+impl Drop for MigrationLock {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_file(&self.path);
+    }
+}
+
+fn acquire_migration_lock() -> Result<Option<MigrationLock>> {
+    let lock_path = GlobalPaths::migration_lock_path()?;
+
+    if let Some(parent) = lock_path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+
+    let file = std::fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(false)
+        .open(&lock_path)?;
+
+    match flock(&file, FlockOperation::NonBlockingLockExclusive) {
+        Ok(()) => Ok(Some(MigrationLock {
+            _file: file,
+            path: lock_path,
+        })),
+        Err(_) => {
+            // Check if lock is stale (older than 1 minute)
+            if let Ok(metadata) = std::fs::metadata(&lock_path) {
+                if let Ok(modified) = metadata.modified() {
+                    if let Ok(elapsed) = modified.elapsed() {
+                        if elapsed.as_secs() > 60 {
+                            // Stale lock - remove and retry
+                            std::fs::remove_file(&lock_path)?;
+                            let file = std::fs::OpenOptions::new()
+                                .create(true)
+                                .write(true)
+                                .truncate(false)
+                                .open(&lock_path)?;
+                            return match flock(&file, FlockOperation::NonBlockingLockExclusive) {
+                                Ok(()) => Ok(Some(MigrationLock {
+                                    _file: file,
+                                    path: lock_path,
+                                })),
+                                Err(_) => Ok(None),
+                            };
+                        }
+                    }
+                }
+            }
+            Ok(None)
+        },
+    }
+}