1package config
2
3import (
4 "cmp"
5 "context"
6 "encoding/json"
7 "fmt"
8 "log/slog"
9 "maps"
10 "os"
11 "os/exec"
12 "path/filepath"
13 "runtime"
14 "slices"
15 "strconv"
16 "strings"
17 "testing"
18
19 "charm.land/catwalk/pkg/catwalk"
20 "github.com/charmbracelet/crush/internal/agent/hyper"
21 "github.com/charmbracelet/crush/internal/csync"
22 "github.com/charmbracelet/crush/internal/env"
23 "github.com/charmbracelet/crush/internal/fsext"
24 "github.com/charmbracelet/crush/internal/home"
25 powernapConfig "github.com/charmbracelet/x/powernap/pkg/config"
26 "github.com/qjebbs/go-jsons"
27)
28
29const defaultCatwalkURL = "https://catwalk.charm.sh"
30
31// Load loads the configuration from the default paths and returns a
32// ConfigStore that owns both the pure-data Config and all runtime state.
33func Load(workingDir, dataDir string, debug bool) (*ConfigStore, error) {
34 configPaths := lookupConfigs(workingDir)
35
36 cfg, loadedPaths, err := loadFromConfigPaths(configPaths)
37 if err != nil {
38 return nil, fmt.Errorf("failed to load config from paths %v: %w", configPaths, err)
39 }
40
41 cfg.setDefaults(workingDir, dataDir)
42
43 store := &ConfigStore{
44 config: cfg,
45 workingDir: workingDir,
46 globalDataPath: GlobalConfigData(),
47 workspacePath: filepath.Join(cfg.Options.DataDirectory, fmt.Sprintf("%s.json", appName)),
48 loadedPaths: loadedPaths,
49 }
50
51 if debug {
52 cfg.Options.Debug = true
53 }
54
55 // Load workspace config last so it has highest priority.
56 if wsData, err := os.ReadFile(store.workspacePath); err == nil && len(wsData) > 0 {
57 merged, mergeErr := loadFromBytes(append([][]byte{mustMarshalConfig(cfg)}, wsData))
58 if mergeErr == nil {
59 // Preserve defaults that setDefaults already applied.
60 dataDir := cfg.Options.DataDirectory
61 *cfg = *merged
62 cfg.setDefaults(workingDir, dataDir)
63 store.config = cfg
64 store.loadedPaths = append(store.loadedPaths, store.workspacePath)
65 }
66 }
67
68 if !isInsideWorktree() {
69 const depth = 2
70 const items = 100
71 slog.Warn("No git repository detected in working directory, will limit file walk operations", "depth", depth, "items", items)
72 assignIfNil(&cfg.Tools.Ls.MaxDepth, depth)
73 assignIfNil(&cfg.Tools.Ls.MaxItems, items)
74 assignIfNil(&cfg.Options.TUI.Completions.MaxDepth, depth)
75 assignIfNil(&cfg.Options.TUI.Completions.MaxItems, items)
76 }
77
78 if isAppleTerminal() {
79 slog.Warn("Detected Apple Terminal, enabling transparent mode")
80 assignIfNil(&cfg.Options.TUI.Transparent, true)
81 }
82
83 // Load known providers, this loads the config from catwalk
84 providers, err := Providers(cfg)
85 if err != nil {
86 return nil, err
87 }
88 store.knownProviders = providers
89
90 env := env.New()
91 // Configure providers
92 valueResolver := NewShellVariableResolver(env)
93 store.resolver = valueResolver
94 if err := cfg.configureProviders(store, env, valueResolver, store.knownProviders); err != nil {
95 return nil, fmt.Errorf("failed to configure providers: %w", err)
96 }
97
98 if !cfg.IsConfigured() {
99 slog.Warn("No providers configured")
100 return store, nil
101 }
102
103 if err := configureSelectedModels(store, store.knownProviders); err != nil {
104 return nil, fmt.Errorf("failed to configure selected models: %w", err)
105 }
106 store.SetupAgents()
107
108 // Capture initial staleness snapshot
109 store.captureStalenessSnapshot(loadedPaths)
110
111 return store, nil
112}
113
114// mustMarshalConfig marshals the config to JSON bytes, returning empty JSON on
115// error.
116func mustMarshalConfig(cfg *Config) []byte {
117 data, err := json.Marshal(cfg)
118 if err != nil {
119 return []byte("{}")
120 }
121 return data
122}
123
124func PushPopCrushEnv() func() {
125 var found []string
126 for _, ev := range os.Environ() {
127 if strings.HasPrefix(ev, "CRUSH_") {
128 pair := strings.SplitN(ev, "=", 2)
129 if len(pair) != 2 {
130 continue
131 }
132 found = append(found, strings.TrimPrefix(pair[0], "CRUSH_"))
133 }
134 }
135 backups := make(map[string]string)
136 for _, ev := range found {
137 backups[ev] = os.Getenv(ev)
138 }
139
140 for _, ev := range found {
141 os.Setenv(ev, os.Getenv("CRUSH_"+ev))
142 }
143
144 restore := func() {
145 for k, v := range backups {
146 os.Setenv(k, v)
147 }
148 }
149 return restore
150}
151
152func (c *Config) configureProviders(store *ConfigStore, env env.Env, resolver VariableResolver, knownProviders []catwalk.Provider) error {
153 knownProviderNames := make(map[string]bool)
154 restore := PushPopCrushEnv()
155 defer restore()
156
157 // When disable_default_providers is enabled, skip all default/embedded
158 // providers entirely. Users must fully specify any providers they want.
159 // We skip to the custom provider validation loop which handles all
160 // user-configured providers uniformly.
161 if c.Options.DisableDefaultProviders {
162 knownProviders = nil
163 }
164
165 for _, p := range knownProviders {
166 knownProviderNames[string(p.ID)] = true
167 config, configExists := c.Providers.Get(string(p.ID))
168 // if the user configured a known provider we need to allow it to override a couple of parameters
169 if configExists {
170 if config.BaseURL != "" {
171 p.APIEndpoint = config.BaseURL
172 }
173 if config.APIKey != "" {
174 p.APIKey = config.APIKey
175 }
176 if len(config.Models) > 0 {
177 models := []catwalk.Model{}
178 seen := make(map[string]bool)
179
180 for _, model := range config.Models {
181 if seen[model.ID] {
182 continue
183 }
184 seen[model.ID] = true
185 if model.Name == "" {
186 model.Name = model.ID
187 }
188 models = append(models, model)
189 }
190 for _, model := range p.Models {
191 if seen[model.ID] {
192 continue
193 }
194 seen[model.ID] = true
195 if model.Name == "" {
196 model.Name = model.ID
197 }
198 models = append(models, model)
199 }
200
201 p.Models = models
202 }
203 }
204
205 headers := map[string]string{}
206 if len(p.DefaultHeaders) > 0 {
207 maps.Copy(headers, p.DefaultHeaders)
208 }
209 if len(config.ExtraHeaders) > 0 {
210 maps.Copy(headers, config.ExtraHeaders)
211 }
212 for k, v := range headers {
213 resolved, err := resolver.ResolveValue(v)
214 if err != nil {
215 slog.Error("Could not resolve provider header", "err", err.Error())
216 continue
217 }
218 headers[k] = resolved
219 }
220 prepared := ProviderConfig{
221 ID: string(p.ID),
222 Name: p.Name,
223 BaseURL: p.APIEndpoint,
224 APIKey: p.APIKey,
225 APIKeyTemplate: p.APIKey, // Store original template for re-resolution
226 OAuthToken: config.OAuthToken,
227 Type: p.Type,
228 Disable: config.Disable,
229 SystemPromptPrefix: config.SystemPromptPrefix,
230 ExtraHeaders: headers,
231 ExtraBody: config.ExtraBody,
232 ExtraParams: make(map[string]string),
233 Models: p.Models,
234 }
235
236 switch {
237 case p.ID == catwalk.InferenceProviderAnthropic && config.OAuthToken != nil:
238 // Claude Code subscription is not supported anymore. Remove to show onboarding.
239 store.RemoveConfigField(ScopeGlobal, "providers.anthropic")
240 c.Providers.Del(string(p.ID))
241 continue
242 case p.ID == catwalk.InferenceProviderCopilot && config.OAuthToken != nil:
243 prepared.SetupGitHubCopilot()
244 }
245
246 switch p.ID {
247 // Handle specific providers that require additional configuration
248 case catwalk.InferenceProviderVertexAI:
249 var (
250 project = env.Get("VERTEXAI_PROJECT")
251 location = env.Get("VERTEXAI_LOCATION")
252 )
253 if project == "" || location == "" {
254 if configExists {
255 slog.Warn("Skipping Vertex AI provider due to missing credentials")
256 c.Providers.Del(string(p.ID))
257 }
258 continue
259 }
260 prepared.ExtraParams["project"] = project
261 prepared.ExtraParams["location"] = location
262 case catwalk.InferenceProviderAzure:
263 endpoint, err := resolver.ResolveValue(p.APIEndpoint)
264 if err != nil || endpoint == "" {
265 if configExists {
266 slog.Warn("Skipping Azure provider due to missing API endpoint", "provider", p.ID, "error", err)
267 c.Providers.Del(string(p.ID))
268 }
269 continue
270 }
271 prepared.BaseURL = endpoint
272 prepared.ExtraParams["apiVersion"] = env.Get("AZURE_OPENAI_API_VERSION")
273 case catwalk.InferenceProviderBedrock:
274 if !hasAWSCredentials(env) {
275 if configExists {
276 slog.Warn("Skipping Bedrock provider due to missing AWS credentials")
277 c.Providers.Del(string(p.ID))
278 }
279 continue
280 }
281 prepared.ExtraParams["region"] = env.Get("AWS_REGION")
282 if prepared.ExtraParams["region"] == "" {
283 prepared.ExtraParams["region"] = env.Get("AWS_DEFAULT_REGION")
284 }
285 for _, model := range p.Models {
286 if !strings.HasPrefix(model.ID, "anthropic.") {
287 return fmt.Errorf("bedrock provider only supports anthropic models for now, found: %s", model.ID)
288 }
289 }
290 default:
291 // if the provider api or endpoint are missing we skip them
292 v, err := resolver.ResolveValue(p.APIKey)
293 if v == "" || err != nil {
294 if configExists {
295 slog.Warn("Skipping provider due to missing API key", "provider", p.ID)
296 c.Providers.Del(string(p.ID))
297 }
298 continue
299 }
300 }
301 c.Providers.Set(string(p.ID), prepared)
302 }
303
304 // validate the custom providers
305 for id, providerConfig := range c.Providers.Seq2() {
306 if knownProviderNames[id] {
307 continue
308 }
309
310 // Make sure the provider ID is set
311 providerConfig.ID = id
312 providerConfig.Name = cmp.Or(providerConfig.Name, id) // Use ID as name if not set
313 // default to OpenAI if not set
314 providerConfig.Type = cmp.Or(providerConfig.Type, catwalk.TypeOpenAICompat)
315 if !slices.Contains(catwalk.KnownProviderTypes(), providerConfig.Type) && providerConfig.Type != hyper.Name {
316 slog.Warn("Skipping custom provider due to unsupported provider type", "provider", id)
317 c.Providers.Del(id)
318 continue
319 }
320
321 if providerConfig.Disable {
322 slog.Debug("Skipping custom provider due to disable flag", "provider", id)
323 c.Providers.Del(id)
324 continue
325 }
326 if providerConfig.APIKey == "" {
327 slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
328 }
329 if providerConfig.BaseURL == "" {
330 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id)
331 c.Providers.Del(id)
332 continue
333 }
334 if len(providerConfig.Models) == 0 {
335 slog.Warn("Skipping custom provider because the provider has no models", "provider", id)
336 c.Providers.Del(id)
337 continue
338 }
339 apiKey, err := resolver.ResolveValue(providerConfig.APIKey)
340 if apiKey == "" || err != nil {
341 slog.Warn("Provider is missing API key, this might be OK for local providers", "provider", id)
342 }
343 baseURL, err := resolver.ResolveValue(providerConfig.BaseURL)
344 if baseURL == "" || err != nil {
345 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id, "error", err)
346 c.Providers.Del(id)
347 continue
348 }
349
350 for k, v := range providerConfig.ExtraHeaders {
351 resolved, err := resolver.ResolveValue(v)
352 if err != nil {
353 slog.Error("Could not resolve provider header", "err", err.Error())
354 continue
355 }
356 providerConfig.ExtraHeaders[k] = resolved
357 }
358
359 c.Providers.Set(id, providerConfig)
360 }
361
362 if c.Providers.Len() == 0 && c.Options.DisableDefaultProviders {
363 return fmt.Errorf("default providers are disabled and there are no custom providers are configured")
364 }
365
366 return nil
367}
368
369func (c *Config) setDefaults(workingDir, dataDir string) {
370 if c.Options == nil {
371 c.Options = &Options{}
372 }
373 if c.Options.TUI == nil {
374 c.Options.TUI = &TUIOptions{}
375 }
376 if dataDir != "" {
377 c.Options.DataDirectory = dataDir
378 } else if c.Options.DataDirectory == "" {
379 if path, ok := fsext.LookupClosest(workingDir, defaultDataDirectory); ok {
380 c.Options.DataDirectory = path
381 } else {
382 c.Options.DataDirectory = filepath.Join(workingDir, defaultDataDirectory)
383 }
384 }
385 if c.Providers == nil {
386 c.Providers = csync.NewMap[string, ProviderConfig]()
387 }
388 if c.Models == nil {
389 c.Models = make(map[SelectedModelType]SelectedModel)
390 }
391 if c.RecentModels == nil {
392 c.RecentModels = make(map[SelectedModelType][]SelectedModel)
393 }
394 if c.MCP == nil {
395 c.MCP = make(map[string]MCPConfig)
396 }
397 if c.LSP == nil {
398 c.LSP = make(map[string]LSPConfig)
399 }
400
401 // Apply defaults to LSP configurations
402 c.applyLSPDefaults()
403
404 // Add the default context paths if they are not already present
405 c.Options.ContextPaths = append(defaultContextPaths, c.Options.ContextPaths...)
406 slices.Sort(c.Options.ContextPaths)
407 c.Options.ContextPaths = slices.Compact(c.Options.ContextPaths)
408
409 // Add the default skills directories if not already present.
410 for _, dir := range GlobalSkillsDirs() {
411 if !slices.Contains(c.Options.SkillsPaths, dir) {
412 c.Options.SkillsPaths = append(c.Options.SkillsPaths, dir)
413 }
414 }
415
416 // Project specific skills dirs.
417 c.Options.SkillsPaths = append(c.Options.SkillsPaths, ProjectSkillsDir(workingDir)...)
418
419 if str, ok := os.LookupEnv("CRUSH_DISABLE_PROVIDER_AUTO_UPDATE"); ok {
420 c.Options.DisableProviderAutoUpdate, _ = strconv.ParseBool(str)
421 }
422
423 if str, ok := os.LookupEnv("CRUSH_DISABLE_DEFAULT_PROVIDERS"); ok {
424 c.Options.DisableDefaultProviders, _ = strconv.ParseBool(str)
425 }
426
427 if c.Options.Attribution == nil {
428 c.Options.Attribution = &Attribution{
429 TrailerStyle: TrailerStyleAssistedBy,
430 GeneratedWith: true,
431 }
432 } else if c.Options.Attribution.TrailerStyle == "" {
433 // Migrate deprecated co_authored_by or apply default
434 if c.Options.Attribution.CoAuthoredBy != nil {
435 if *c.Options.Attribution.CoAuthoredBy {
436 c.Options.Attribution.TrailerStyle = TrailerStyleCoAuthoredBy
437 } else {
438 c.Options.Attribution.TrailerStyle = TrailerStyleNone
439 }
440 } else {
441 c.Options.Attribution.TrailerStyle = TrailerStyleAssistedBy
442 }
443 }
444 c.Options.InitializeAs = cmp.Or(c.Options.InitializeAs, defaultInitializeAs)
445}
446
447// applyLSPDefaults applies default values from powernap to LSP configurations
448func (c *Config) applyLSPDefaults() {
449 // Get powernap's default configuration
450 configManager := powernapConfig.NewManager()
451 configManager.LoadDefaults()
452
453 // Apply defaults to each LSP configuration
454 for name, cfg := range c.LSP {
455 // Try to get defaults from powernap based on name or command name.
456 base, ok := configManager.GetServer(name)
457 if !ok {
458 base, ok = configManager.GetServer(cfg.Command)
459 if !ok {
460 continue
461 }
462 }
463 if cfg.Options == nil {
464 cfg.Options = base.Settings
465 }
466 if cfg.InitOptions == nil {
467 cfg.InitOptions = base.InitOptions
468 }
469 if len(cfg.FileTypes) == 0 {
470 cfg.FileTypes = base.FileTypes
471 }
472 if len(cfg.RootMarkers) == 0 {
473 cfg.RootMarkers = base.RootMarkers
474 }
475 cfg.Command = cmp.Or(cfg.Command, base.Command)
476 if len(cfg.Args) == 0 {
477 cfg.Args = base.Args
478 }
479 if len(cfg.Env) == 0 {
480 cfg.Env = base.Environment
481 }
482 // Update the config in the map
483 c.LSP[name] = cfg
484 }
485}
486
487func (c *Config) defaultModelSelection(knownProviders []catwalk.Provider) (largeModel SelectedModel, smallModel SelectedModel, err error) {
488 if len(knownProviders) == 0 && c.Providers.Len() == 0 {
489 err = fmt.Errorf("no providers configured, please configure at least one provider")
490 return largeModel, smallModel, err
491 }
492
493 // Use the first provider enabled based on the known providers order
494 // if no provider found that is known use the first provider configured
495 for _, p := range knownProviders {
496 providerConfig, ok := c.Providers.Get(string(p.ID))
497 if !ok || providerConfig.Disable {
498 continue
499 }
500 defaultLargeModel := c.GetModel(string(p.ID), p.DefaultLargeModelID)
501 if defaultLargeModel == nil {
502 err = fmt.Errorf("default large model %s not found for provider %s", p.DefaultLargeModelID, p.ID)
503 return largeModel, smallModel, err
504 }
505 largeModel = SelectedModel{
506 Provider: string(p.ID),
507 Model: defaultLargeModel.ID,
508 MaxTokens: defaultLargeModel.DefaultMaxTokens,
509 ReasoningEffort: defaultLargeModel.DefaultReasoningEffort,
510 }
511
512 defaultSmallModel := c.GetModel(string(p.ID), p.DefaultSmallModelID)
513 if defaultSmallModel == nil {
514 err = fmt.Errorf("default small model %s not found for provider %s", p.DefaultSmallModelID, p.ID)
515 return largeModel, smallModel, err
516 }
517 smallModel = SelectedModel{
518 Provider: string(p.ID),
519 Model: defaultSmallModel.ID,
520 MaxTokens: defaultSmallModel.DefaultMaxTokens,
521 ReasoningEffort: defaultSmallModel.DefaultReasoningEffort,
522 }
523 return largeModel, smallModel, err
524 }
525
526 enabledProviders := c.EnabledProviders()
527 slices.SortFunc(enabledProviders, func(a, b ProviderConfig) int {
528 return strings.Compare(a.ID, b.ID)
529 })
530
531 if len(enabledProviders) == 0 {
532 err = fmt.Errorf("no providers configured, please configure at least one provider")
533 return largeModel, smallModel, err
534 }
535
536 providerConfig := enabledProviders[0]
537 if len(providerConfig.Models) == 0 {
538 err = fmt.Errorf("provider %s has no models configured", providerConfig.ID)
539 return largeModel, smallModel, err
540 }
541 defaultLargeModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
542 largeModel = SelectedModel{
543 Provider: providerConfig.ID,
544 Model: defaultLargeModel.ID,
545 MaxTokens: defaultLargeModel.DefaultMaxTokens,
546 }
547 defaultSmallModel := c.GetModel(providerConfig.ID, providerConfig.Models[0].ID)
548 smallModel = SelectedModel{
549 Provider: providerConfig.ID,
550 Model: defaultSmallModel.ID,
551 MaxTokens: defaultSmallModel.DefaultMaxTokens,
552 }
553 return largeModel, smallModel, err
554}
555
556func configureSelectedModels(store *ConfigStore, knownProviders []catwalk.Provider) error {
557 c := store.config
558 defaultLarge, defaultSmall, err := c.defaultModelSelection(knownProviders)
559 if err != nil {
560 return fmt.Errorf("failed to select default models: %w", err)
561 }
562 large, small := defaultLarge, defaultSmall
563
564 largeModelSelected, largeModelConfigured := c.Models[SelectedModelTypeLarge]
565 if largeModelConfigured {
566 if largeModelSelected.Model != "" {
567 large.Model = largeModelSelected.Model
568 }
569 if largeModelSelected.Provider != "" {
570 large.Provider = largeModelSelected.Provider
571 }
572 model := c.GetModel(large.Provider, large.Model)
573 if model == nil {
574 large = defaultLarge
575 // override the model type to large
576 err := store.UpdatePreferredModel(ScopeGlobal, SelectedModelTypeLarge, large)
577 if err != nil {
578 return fmt.Errorf("failed to update preferred large model: %w", err)
579 }
580 } else {
581 if largeModelSelected.MaxTokens > 0 {
582 large.MaxTokens = largeModelSelected.MaxTokens
583 } else {
584 large.MaxTokens = model.DefaultMaxTokens
585 }
586 if largeModelSelected.ReasoningEffort != "" {
587 large.ReasoningEffort = largeModelSelected.ReasoningEffort
588 }
589 large.Think = largeModelSelected.Think
590 if largeModelSelected.Temperature != nil {
591 large.Temperature = largeModelSelected.Temperature
592 }
593 if largeModelSelected.TopP != nil {
594 large.TopP = largeModelSelected.TopP
595 }
596 if largeModelSelected.TopK != nil {
597 large.TopK = largeModelSelected.TopK
598 }
599 if largeModelSelected.FrequencyPenalty != nil {
600 large.FrequencyPenalty = largeModelSelected.FrequencyPenalty
601 }
602 if largeModelSelected.PresencePenalty != nil {
603 large.PresencePenalty = largeModelSelected.PresencePenalty
604 }
605 }
606 }
607 smallModelSelected, smallModelConfigured := c.Models[SelectedModelTypeSmall]
608 if smallModelConfigured {
609 if smallModelSelected.Model != "" {
610 small.Model = smallModelSelected.Model
611 }
612 if smallModelSelected.Provider != "" {
613 small.Provider = smallModelSelected.Provider
614 }
615
616 model := c.GetModel(small.Provider, small.Model)
617 if model == nil {
618 small = defaultSmall
619 // override the model type to small
620 err := store.UpdatePreferredModel(ScopeGlobal, SelectedModelTypeSmall, small)
621 if err != nil {
622 return fmt.Errorf("failed to update preferred small model: %w", err)
623 }
624 } else {
625 if smallModelSelected.MaxTokens > 0 {
626 small.MaxTokens = smallModelSelected.MaxTokens
627 } else {
628 small.MaxTokens = model.DefaultMaxTokens
629 }
630 if smallModelSelected.ReasoningEffort != "" {
631 small.ReasoningEffort = smallModelSelected.ReasoningEffort
632 }
633 if smallModelSelected.Temperature != nil {
634 small.Temperature = smallModelSelected.Temperature
635 }
636 if smallModelSelected.TopP != nil {
637 small.TopP = smallModelSelected.TopP
638 }
639 if smallModelSelected.TopK != nil {
640 small.TopK = smallModelSelected.TopK
641 }
642 if smallModelSelected.FrequencyPenalty != nil {
643 small.FrequencyPenalty = smallModelSelected.FrequencyPenalty
644 }
645 if smallModelSelected.PresencePenalty != nil {
646 small.PresencePenalty = smallModelSelected.PresencePenalty
647 }
648 small.Think = smallModelSelected.Think
649 }
650 }
651 c.Models[SelectedModelTypeLarge] = large
652 c.Models[SelectedModelTypeSmall] = small
653 return nil
654}
655
656// lookupConfigs searches config files recursively from CWD up to FS root
657func lookupConfigs(cwd string) []string {
658 // prepend default config paths
659 configPaths := []string{
660 GlobalConfig(),
661 GlobalConfigData(),
662 }
663
664 configNames := []string{appName + ".json", "." + appName + ".json"}
665
666 foundConfigs, err := fsext.Lookup(cwd, configNames...)
667 if err != nil {
668 // returns at least default configs
669 return configPaths
670 }
671
672 // reverse order so last config has more priority
673 slices.Reverse(foundConfigs)
674
675 return append(configPaths, foundConfigs...)
676}
677
678func loadFromConfigPaths(configPaths []string) (*Config, []string, error) {
679 var configs [][]byte
680 var loaded []string
681
682 for _, path := range configPaths {
683 data, err := os.ReadFile(path)
684 if err != nil {
685 if os.IsNotExist(err) {
686 continue
687 }
688 return nil, nil, fmt.Errorf("failed to open config file %s: %w", path, err)
689 }
690 if len(data) == 0 {
691 continue
692 }
693 configs = append(configs, data)
694 loaded = append(loaded, path)
695 }
696
697 cfg, err := loadFromBytes(configs)
698 if err != nil {
699 return nil, nil, err
700 }
701 return cfg, loaded, nil
702}
703
704func loadFromBytes(configs [][]byte) (*Config, error) {
705 if len(configs) == 0 {
706 return &Config{}, nil
707 }
708
709 data, err := jsons.Merge(configs)
710 if err != nil {
711 return nil, err
712 }
713 var config Config
714 if err := json.Unmarshal(data, &config); err != nil {
715 return nil, err
716 }
717 return &config, nil
718}
719
720func hasAWSCredentials(env env.Env) bool {
721 if env.Get("AWS_BEARER_TOKEN_BEDROCK") != "" {
722 return true
723 }
724
725 if env.Get("AWS_ACCESS_KEY_ID") != "" && env.Get("AWS_SECRET_ACCESS_KEY") != "" {
726 return true
727 }
728
729 if env.Get("AWS_PROFILE") != "" || env.Get("AWS_DEFAULT_PROFILE") != "" {
730 return true
731 }
732
733 if env.Get("AWS_REGION") != "" || env.Get("AWS_DEFAULT_REGION") != "" {
734 return true
735 }
736
737 if env.Get("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") != "" ||
738 env.Get("AWS_CONTAINER_CREDENTIALS_FULL_URI") != "" {
739 return true
740 }
741
742 if _, err := os.Stat(filepath.Join(home.Dir(), ".aws/credentials")); err == nil && !testing.Testing() {
743 return true
744 }
745
746 return false
747}
748
749// GlobalConfig returns the global configuration file path for the application.
750func GlobalConfig() string {
751 if crushGlobal := os.Getenv("CRUSH_GLOBAL_CONFIG"); crushGlobal != "" {
752 return filepath.Join(crushGlobal, fmt.Sprintf("%s.json", appName))
753 }
754 return filepath.Join(home.Config(), appName, fmt.Sprintf("%s.json", appName))
755}
756
757// GlobalCacheDir returns the path to the global cache directory for the
758// application.
759func GlobalCacheDir() string {
760 if crushCache := os.Getenv("CRUSH_CACHE_DIR"); crushCache != "" {
761 return crushCache
762 }
763 if xdgCacheHome := os.Getenv("XDG_CACHE_HOME"); xdgCacheHome != "" {
764 return filepath.Join(xdgCacheHome, appName)
765 }
766 if runtime.GOOS == "windows" {
767 localAppData := cmp.Or(
768 os.Getenv("LOCALAPPDATA"),
769 filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local"),
770 )
771 return filepath.Join(localAppData, appName, "cache")
772 }
773 return filepath.Join(home.Dir(), ".cache", appName)
774}
775
776// GlobalConfigData returns the path to the main data directory for the application.
777// this config is used when the app overrides configurations instead of updating the global config.
778func GlobalConfigData() string {
779 if crushData := os.Getenv("CRUSH_GLOBAL_DATA"); crushData != "" {
780 return filepath.Join(crushData, fmt.Sprintf("%s.json", appName))
781 }
782 if xdgDataHome := os.Getenv("XDG_DATA_HOME"); xdgDataHome != "" {
783 return filepath.Join(xdgDataHome, appName, fmt.Sprintf("%s.json", appName))
784 }
785
786 // return the path to the main data directory
787 // for windows, it should be in `%LOCALAPPDATA%/crush/`
788 // for linux and macOS, it should be in `$HOME/.local/share/crush/`
789 if runtime.GOOS == "windows" {
790 localAppData := cmp.Or(
791 os.Getenv("LOCALAPPDATA"),
792 filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local"),
793 )
794 return filepath.Join(localAppData, appName, fmt.Sprintf("%s.json", appName))
795 }
796
797 return filepath.Join(home.Dir(), ".local", "share", appName, fmt.Sprintf("%s.json", appName))
798}
799
800// GlobalWorkspaceDir returns the path to the global server workspace
801// directory. This directory acts as a meta-workspace for the server
802// process, giving it a real workingDir so that config loading, scoped
803// writes, and provider resolution behave identically to project
804// workspaces.
805func GlobalWorkspaceDir() string {
806 return filepath.Dir(GlobalConfigData())
807}
808
809func assignIfNil[T any](ptr **T, val T) {
810 if *ptr == nil {
811 *ptr = &val
812 }
813}
814
815func isInsideWorktree() bool {
816 bts, err := exec.CommandContext(
817 context.Background(),
818 "git", "rev-parse",
819 "--is-inside-work-tree",
820 ).CombinedOutput()
821 return err == nil && strings.TrimSpace(string(bts)) == "true"
822}
823
824// GlobalSkillsDirs returns the default directories for Agent Skills.
825// Skills in these directories are auto-discovered and their files can be read
826// without permission prompts.
827func GlobalSkillsDirs() []string {
828 if crushSkills := os.Getenv("CRUSH_SKILLS_DIR"); crushSkills != "" {
829 return []string{crushSkills}
830 }
831
832 paths := []string{
833 filepath.Join(home.Config(), appName, "skills"),
834 filepath.Join(home.Config(), "agents", "skills"),
835 }
836
837 // On Windows, also load from app data on top of `$HOME/.config/crush`.
838 // This is here mostly for backwards compatibility.
839 if runtime.GOOS == "windows" {
840 appData := cmp.Or(
841 os.Getenv("LOCALAPPDATA"),
842 filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local"),
843 )
844 paths = append(
845 paths,
846 filepath.Join(appData, appName, "skills"),
847 filepath.Join(appData, "agents", "skills"),
848 )
849 }
850
851 return paths
852}
853
854// ProjectSkillsDir returns the default project directories for which Crush
855// will look for skills.
856func ProjectSkillsDir(workingDir string) []string {
857 return []string{
858 filepath.Join(workingDir, ".agents/skills"),
859 filepath.Join(workingDir, ".crush/skills"),
860 filepath.Join(workingDir, ".claude/skills"),
861 filepath.Join(workingDir, ".cursor/skills"),
862 }
863}
864
865func isAppleTerminal() bool { return os.Getenv("TERM_PROGRAM") == "Apple_Terminal" }