feat: migrate dotfiles as part of kiro migration

Author: brandonskiser

crates/fig_desktop/src/install.rs

@@ -56,7 +56,7 @@ fn run_input_method_migration() {
 pub async fn run_install(ctx: Arc<Context>, ignore_immediate_update: bool) {
     #[cfg(target_os = "macos")]
     {
-        initialize_fig_dir(&fig_os_shim::Env::new()).await.ok();
+        initialize_fig_dir(&fig_os_shim::Context::new()).await.ok();
 
         if fig_util::directories::home_dir()
             .map(|home| home.join("Library/Application Support/fig/credentials.json"))
@@ -201,7 +201,7 @@ async fn symlink(src: impl AsRef<std::path::Path>, dst: impl AsRef<std::path::Pa
 }
 
 #[cfg(target_os = "macos")]
-pub async fn initialize_fig_dir(env: &fig_os_shim::Env) -> anyhow::Result<()> {
+pub async fn initialize_fig_dir(ctx: &fig_os_shim::Context) -> anyhow::Result<()> {
     use std::fs;
 
     use fig_integrations::shell::ShellExt;
@@ -381,7 +381,7 @@ pub async fn initialize_fig_dir(env: &fig_os_shim::Env) -> anyhow::Result<()> {
             }
         }
 
-        for shell_integration in shell.get_shell_integrations(env).unwrap_or_default() {
+        for shell_integration in shell.get_shell_integrations(ctx).unwrap_or_default() {
             if let Err(err) = shell_integration.migrate().await {
                 error!(%err, "Failed installing shell integration {}", shell_integration.describe());
             }

crates/fig_desktop/src/request/onboarding.rs

@@ -2,7 +2,6 @@ use fig_integrations::shell::ShellExt;
 use fig_os_shim::{
     ContextArcProvider,
     ContextProvider,
-    EnvProvider,
 };
 use fig_proto::fig::{
     OnboardingAction,
@@ -38,7 +37,7 @@ where
         OnboardingAction::InstallationScript => {
             let mut errs: Vec<String> = vec![];
             for shell in [Shell::Bash, Shell::Zsh, Shell::Fish] {
-                match shell.get_shell_integrations(ctx.env()) {
+                match shell.get_shell_integrations(ctx) {
                     Ok(integrations) => {
                         for integration in integrations {
                             if let Err(err) = integration.install().await {

crates/fig_desktop_api/src/requests/install.rs

@@ -73,7 +73,7 @@ where
         (InstallComponent::Dotfiles, action) => {
             let mut errs: Vec<String> = vec![];
             for shell in Shell::all() {
-                match shell.get_shell_integrations(ctx.env()) {
+                match shell.get_shell_integrations(ctx) {
                     Ok(integrations) => {
                         for integration in integrations {
                             let res = match action {

crates/fig_install/src/common.rs

@@ -6,7 +6,9 @@ use fig_integrations::shell::ShellExt;
 use fig_integrations::ssh::SshIntegration;
 use fig_os_shim::{
     Context,
-    Env,
+    EnvProvider,
+    FsProvider,
+    PlatformProvider,
 };
 use fig_util::{
     CHAT_BINARY_NAME,
@@ -53,7 +55,7 @@ pub async fn uninstall(components: InstallComponents, ctx: Arc<Context>) -> Resu
 
     let shell_integration_result = {
         for shell in [Shell::Bash, Shell::Zsh, Shell::Fish] {
-            for integration in shell.get_shell_integrations(ctx.env())? {
+            for integration in shell.get_shell_integrations(&ctx)? {
                 integration.uninstall().await?;
             }
         }
@@ -139,11 +141,14 @@ pub async fn uninstall(components: InstallComponents, ctx: Arc<Context>) -> Resu
         .and(ssh_result.map_err(|e| e.into()))
 }
 
-pub async fn install(components: InstallComponents, env: &Env) -> Result<(), Error> {
+pub async fn install<Ctx: FsProvider + EnvProvider + PlatformProvider>(
+    components: InstallComponents,
+    ctx: &Ctx,
+) -> Result<(), Error> {
     if components.contains(InstallComponents::SHELL_INTEGRATIONS) {
         let mut errs: Vec<Error> = vec![];
         for shell in Shell::all() {
-            match shell.get_shell_integrations(env) {
+            match shell.get_shell_integrations(ctx) {
                 Ok(integrations) => {
                     for integration in integrations {
                         if let Err(e) = integration.install().await {

crates/fig_install/src/migrate.rs

@@ -1,13 +1,19 @@
 use std::path::PathBuf;
 
 use eyre::Result;
+use fig_integrations::shell::ShellExt;
+use fig_os_shim::Context;
+use fig_util::Shell;
 use rustix::fs::{
     FlockOperation,
     flock,
 };
 use serde_json::Value;
 use tokio::fs;
-use tracing::debug;
+use tracing::{
+    debug,
+    warn,
+};
 
 const KIRO_MIGRATION_KEY: &str = "migration.kiro.completed";
 const MIGRATION_TIMEOUT_SECS: u64 = 60;
@@ -52,6 +58,12 @@ pub async fn migrate_if_needed() -> Result<bool> {
     debug!("Copying essential files from old to new directory");
     copy_essential_files(&old_dir, &new_dir).await?;
 
+    debug!("Migrating shell integrations");
+    let errors = migrate_dotfiles().await;
+    if !errors.is_empty() {
+        warn!(?errors, "errors occurred migrating shell integrations");
+    }
+
     // Mark migration as completed in database
     debug!("Marking migration as completed");
     mark_migration_completed()?;
@@ -221,6 +233,52 @@ fn merge_mcp_json(src_path: &std::path::Path, dst_path: &std::path::Path) -> Res
     Ok(())
 }
 
+async fn migrate_dotfiles() -> Vec<(Shell, fig_integrations::Error)> {
+    let shells = Shell::all();
+    let mut errors = Vec::new();
+
+    // First, collect all available shell integrations
+    let mut shell_integrations = Vec::new();
+    for shell in shells {
+        match shell.get_shell_integrations(&Context::new()) {
+            Ok(integrations) => {
+                for integ in integrations {
+                    shell_integrations.push((*shell, integ));
+                }
+            },
+            Err(err) => errors.push((*shell, err)),
+        }
+    }
+
+    // Because the fish shell doesn't support detecting legacy installations (and
+    // therefore migrating), we're going to iterate through all shells (ie, bash and zsh) to see if a
+    // legacy installation is detected. If so, then perform the migration.
+    let mut has_legacy_installation = None;
+    for (shell, integ) in &shell_integrations {
+        if let Err(fig_integrations::Error::LegacyInstallation(_)) = integ.is_installed().await {
+            has_legacy_installation = Some(shell);
+        }
+    }
+
+    if let Some(shell) = has_legacy_installation {
+        debug!(
+            ?shell,
+            "detected legacy dotfile installation, installing dotfile integrations"
+        );
+    } else {
+        debug!("no legacy dotfile installation detected, not migrating dotfiles");
+        return vec![];
+    }
+
+    for (shell, integration) in shell_integrations {
+        if let Err(err) = integration.install().await {
+            errors.push((shell, err));
+        }
+    }
+
+    errors
+}
+
 fn mark_migration_completed() -> Result<()> {
     let db = fig_settings::sqlite::database()?;
     db.set_state_value(KIRO_MIGRATION_KEY, true)?;
@@ -287,3 +345,15 @@ fn migration_lock_path() -> Result<PathBuf> {
 fn is_migration_completed() -> Result<bool> {
     Ok(fig_settings::state::get_bool_or(KIRO_MIGRATION_KEY, false))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    #[ignore = "not in ci"]
+    async fn integ_test_migration() {
+        let _ = tracing_subscriber::fmt::try_init();
+        migrate_if_needed().await.unwrap();
+    }
+}