Make it startable from playwright and also isolate (#5016)

Co-authored-by: Douwe Osinga <douwe@squareup.com>

crates/goose/src/config/base.rs

@@ -1,7 +1,7 @@
-use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};
+use crate::config::paths::Paths;
 use fs2::FileExt;
 use keyring::Entry;
-use once_cell::sync::{Lazy, OnceCell};
+use once_cell::sync::OnceCell;
 use serde::Deserialize;
 use serde_json::Value;
 use std::collections::HashMap;
@@ -11,12 +11,6 @@ use std::io::Write;
 use std::path::{Path, PathBuf};
 use thiserror::Error;
 
-pub static APP_STRATEGY: Lazy<AppStrategyArgs> = Lazy::new(|| AppStrategyArgs {
-    top_level_domain: "Block".to_string(),
-    author: "Block".to_string(),
-    app_name: "goose".to_string(),
-});
-
 const KEYRING_SERVICE: &str = "goose";
 const KEYRING_USERNAME: &str = "secrets";
 
@@ -116,18 +110,9 @@ enum SecretStorage {
 // Global instance
 static GLOBAL_CONFIG: OnceCell<Config> = OnceCell::new();
 
-pub fn get_config_dir() -> PathBuf {
-    choose_app_strategy(APP_STRATEGY.clone())
-        .expect("goose requires a home dir")
-        .config_dir()
-}
-
 impl Default for Config {
     fn default() -> Self {
-        // choose_app_strategy().config_dir()
-        // - macOS/Linux: ~/.config/goose/
-        // - Windows:     ~\AppData\Roaming\Block\goose\config\
-        let config_dir = get_config_dir();
+        let config_dir = Paths::config_dir();
 
         std::fs::create_dir_all(&config_dir).expect("Failed to create config directory");
 

crates/goose/src/config/custom_providers.rs

@@ -1,20 +1,17 @@
-use crate::config::{Config, APP_STRATEGY};
+use crate::config::paths::Paths;
+use crate::config::Config;
 use crate::model::ModelConfig;
 use crate::providers::anthropic::AnthropicProvider;
 use crate::providers::base::ModelInfo;
 use crate::providers::ollama::OllamaProvider;
 use crate::providers::openai::OpenAiProvider;
 use anyhow::Result;
-use etcetera::{choose_app_strategy, AppStrategy};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::path::Path;
 
 pub fn custom_providers_dir() -> std::path::PathBuf {
-    choose_app_strategy(APP_STRATEGY.clone())
-        .expect("goose requires a home dir")
-        .config_dir()
-        .join("custom_providers")
+    Paths::config_dir().join("custom_providers")
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

crates/goose/src/config/mod.rs

@@ -2,12 +2,13 @@ pub mod base;
 pub mod custom_providers;
 mod experiments;
 pub mod extensions;
+pub mod paths;
 pub mod permission;
 pub mod signup_openrouter;
 pub mod signup_tetrate;
 
 pub use crate::agents::ExtensionConfig;
-pub use base::{get_config_dir, Config, ConfigError, APP_STRATEGY};
+pub use base::{Config, ConfigError};
 pub use custom_providers::CustomProviderConfig;
 pub use experiments::ExperimentManager;
 pub use extensions::{

crates/goose/src/config/paths.rs

@@ -0,0 +1,60 @@
+use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};
+use std::path::PathBuf;
+
+pub struct Paths;
+
+impl Paths {
+    fn get_dir(dir_type: DirType) -> PathBuf {
+        if let Ok(test_root) = std::env::var("GOOSE_PATH_ROOT") {
+            let base = PathBuf::from(test_root);
+            match dir_type {
+                DirType::Config => base.join("config"),
+                DirType::Data => base.join("data"),
+                DirType::State => base.join("state"),
+            }
+        } else {
+            let strategy = choose_app_strategy(AppStrategyArgs {
+                top_level_domain: "Block".to_string(),
+                author: "Block".to_string(),
+                app_name: "goose".to_string(),
+            })
+            .expect("goose requires a home dir");
+
+            match dir_type {
+                DirType::Config => strategy.config_dir(),
+                DirType::Data => strategy.data_dir(),
+                DirType::State => strategy.state_dir().unwrap_or(strategy.data_dir()),
+            }
+        }
+    }
+
+    pub fn config_dir() -> PathBuf {
+        Self::get_dir(DirType::Config)
+    }
+
+    pub fn data_dir() -> PathBuf {
+        Self::get_dir(DirType::Data)
+    }
+
+    pub fn state_dir() -> PathBuf {
+        Self::get_dir(DirType::State)
+    }
+
+    pub fn in_state_dir(subpath: &str) -> PathBuf {
+        Self::state_dir().join(subpath)
+    }
+
+    pub fn in_config_dir(subpath: &str) -> PathBuf {
+        Self::config_dir().join(subpath)
+    }
+
+    pub fn in_data_dir(subpath: &str) -> PathBuf {
+        Self::data_dir().join(subpath)
+    }
+}
+
+enum DirType {
+    Config,
+    Data,
+    State,
+}

crates/goose/src/config/permission.rs

@@ -1,5 +1,4 @@
-use super::APP_STRATEGY;
-use etcetera::{choose_app_strategy, AppStrategy};
+use crate::config::paths::Paths;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::fs;
@@ -37,14 +36,7 @@ const SMART_APPROVE_PERMISSION: &str = "smart_approve";
 /// Implements the default constructor for `PermissionManager`.
 impl Default for PermissionManager {
     fn default() -> Self {
-        // Choose the app strategy and determine the config directory
-        let config_dir = choose_app_strategy(APP_STRATEGY.clone())
-            .expect("goose requires a home dir")
-            .config_dir();
-
-        // Ensure the configuration directory exists
-        std::fs::create_dir_all(&config_dir).expect("Failed to create config directory");
-        let config_path = config_dir.join("permission.yaml");
+        let config_path = Paths::config_dir().join("permission.yaml");
 
         // Load the existing configuration file or create an empty map if the file doesn't exist
         let permission_map = if config_path.exists() {