1package config
2
3import (
4 "encoding/json"
5 "fmt"
6 "io"
7 "os"
8 "path/filepath"
9 "runtime"
10 "slices"
11 "strings"
12
13 "github.com/charmbracelet/crush/internal/fur/client"
14 "github.com/charmbracelet/crush/internal/fur/provider"
15 "github.com/charmbracelet/crush/pkg/env"
16 "github.com/charmbracelet/crush/pkg/log"
17 "golang.org/x/exp/slog"
18)
19
20// LoadReader config via io.Reader.
21func LoadReader(fd io.Reader) (*Config, error) {
22 data, err := io.ReadAll(fd)
23 if err != nil {
24 return nil, err
25 }
26
27 var config Config
28 err = json.Unmarshal(data, &config)
29 if err != nil {
30 return nil, err
31 }
32 return &config, err
33}
34
35// Load loads the configuration from the default paths.
36func Load(workingDir string, debug bool) (*Config, error) {
37 // uses default config paths
38 configPaths := []string{
39 globalConfig(),
40 globalConfigData(),
41 filepath.Join(workingDir, fmt.Sprintf("%s.json", appName)),
42 filepath.Join(workingDir, fmt.Sprintf(".%s.json", appName)),
43 }
44 cfg, err := loadFromConfigPaths(configPaths)
45
46 if debug {
47 cfg.Options.Debug = true
48 }
49
50 // Init logs
51 log.Init(
52 filepath.Join(cfg.Options.DataDirectory, "logs", fmt.Sprintf("%s.log", appName)),
53 cfg.Options.Debug,
54 )
55
56 if err != nil {
57 return nil, fmt.Errorf("failed to load config: %w", err)
58 }
59
60 cfg.setDefaults(workingDir)
61
62 // Load known providers, this loads the config from fur
63 providers, err := LoadProviders(client.New())
64 if err != nil || len(providers) == 0 {
65 return nil, fmt.Errorf("failed to load providers: %w", err)
66 }
67
68 env := env.New()
69 // Configure providers
70 valueResolver := NewShellVariableResolver(env)
71 if err := cfg.configureProviders(env, valueResolver, providers); err != nil {
72 return nil, fmt.Errorf("failed to configure providers: %w", err)
73 }
74
75 if !cfg.IsConfigured() {
76 slog.Warn("No providers configured")
77 return cfg, nil
78 }
79
80 // largeModel, ok := cfg.Models[SelectedModelTypeLarge]
81 // if !ok {
82 // // set default
83 // }
84 // smallModel, ok := cfg.Models[SelectedModelTypeSmall]
85 // if !ok {
86 // // set default
87 // }
88 //
89 return cfg, nil
90}
91
92func (cfg *Config) configureProviders(env env.Env, resolver VariableResolver, knownProviders []provider.Provider) error {
93 knownProviderNames := make(map[string]bool)
94 for _, p := range knownProviders {
95 knownProviderNames[string(p.ID)] = true
96 config, configExists := cfg.Providers[string(p.ID)]
97 // if the user configured a known provider we need to allow it to override a couple of parameters
98 if configExists {
99 if config.Disable {
100 slog.Debug("Skipping provider due to disable flag", "provider", p.ID)
101 delete(cfg.Providers, string(p.ID))
102 continue
103 }
104 if config.BaseURL != "" {
105 p.APIEndpoint = config.BaseURL
106 }
107 if config.APIKey != "" {
108 p.APIKey = config.APIKey
109 }
110 if len(config.Models) > 0 {
111 models := []provider.Model{}
112 seen := make(map[string]bool)
113
114 for _, model := range config.Models {
115 if seen[model.ID] {
116 continue
117 }
118 seen[model.ID] = true
119 models = append(models, model)
120 }
121 for _, model := range p.Models {
122 if seen[model.ID] {
123 continue
124 }
125 seen[model.ID] = true
126 models = append(models, model)
127 }
128
129 p.Models = models
130 }
131 }
132 prepared := ProviderConfig{
133 ID: string(p.ID),
134 BaseURL: p.APIEndpoint,
135 APIKey: p.APIKey,
136 Type: p.Type,
137 Disable: config.Disable,
138 ExtraHeaders: config.ExtraHeaders,
139 ExtraParams: make(map[string]string),
140 Models: p.Models,
141 }
142
143 switch p.ID {
144 // Handle specific providers that require additional configuration
145 case provider.InferenceProviderVertexAI:
146 if !hasVertexCredentials(env) {
147 if configExists {
148 slog.Warn("Skipping Vertex AI provider due to missing credentials")
149 delete(cfg.Providers, string(p.ID))
150 }
151 continue
152 }
153 prepared.ExtraParams["project"] = env.Get("GOOGLE_CLOUD_PROJECT")
154 prepared.ExtraParams["location"] = env.Get("GOOGLE_CLOUD_LOCATION")
155 case provider.InferenceProviderBedrock:
156 if !hasAWSCredentials(env) {
157 if configExists {
158 slog.Warn("Skipping Bedrock provider due to missing AWS credentials")
159 delete(cfg.Providers, string(p.ID))
160 }
161 continue
162 }
163 for _, model := range p.Models {
164 if !strings.HasPrefix(model.ID, "anthropic.") {
165 return fmt.Errorf("bedrock provider only supports anthropic models for now, found: %s", model.ID)
166 }
167 }
168 default:
169 // if the provider api or endpoint are missing we skip them
170 v, err := resolver.ResolveValue(p.APIKey)
171 if v == "" || err != nil {
172 if configExists {
173 slog.Warn("Skipping provider due to missing API key", "provider", p.ID)
174 delete(cfg.Providers, string(p.ID))
175 }
176 continue
177 }
178 }
179 cfg.Providers[string(p.ID)] = prepared
180 }
181
182 // validate the custom providers
183 for id, providerConfig := range cfg.Providers {
184 if knownProviderNames[id] {
185 continue
186 }
187
188 // Make sure the provider ID is set
189 providerConfig.ID = id
190 // default to OpenAI if not set
191 if providerConfig.Type == "" {
192 providerConfig.Type = provider.TypeOpenAI
193 }
194
195 if providerConfig.Disable {
196 slog.Debug("Skipping custom provider due to disable flag", "provider", id)
197 delete(cfg.Providers, id)
198 continue
199 }
200 if providerConfig.APIKey == "" {
201 slog.Warn("Skipping custom provider due to missing API key", "provider", id)
202 delete(cfg.Providers, id)
203 continue
204 }
205 if providerConfig.BaseURL == "" {
206 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id)
207 delete(cfg.Providers, id)
208 continue
209 }
210 if len(providerConfig.Models) == 0 {
211 slog.Warn("Skipping custom provider because the provider has no models", "provider", id)
212 delete(cfg.Providers, id)
213 continue
214 }
215 if providerConfig.Type != provider.TypeOpenAI {
216 slog.Warn("Skipping custom provider because the provider type is not supported", "provider", id, "type", providerConfig.Type)
217 delete(cfg.Providers, id)
218 continue
219 }
220
221 apiKey, err := resolver.ResolveValue(providerConfig.APIKey)
222 if apiKey == "" || err != nil {
223 slog.Warn("Skipping custom provider due to missing API key", "provider", id, "error", err)
224 delete(cfg.Providers, id)
225 continue
226 }
227 baseURL, err := resolver.ResolveValue(providerConfig.BaseURL)
228 if baseURL == "" || err != nil {
229 slog.Warn("Skipping custom provider due to missing API endpoint", "provider", id, "error", err)
230 delete(cfg.Providers, id)
231 continue
232 }
233
234 cfg.Providers[id] = providerConfig
235 }
236 return nil
237}
238
239func hasVertexCredentials(env env.Env) bool {
240 useVertex := env.Get("GOOGLE_GENAI_USE_VERTEXAI") == "true"
241 hasProject := env.Get("GOOGLE_CLOUD_PROJECT") != ""
242 hasLocation := env.Get("GOOGLE_CLOUD_LOCATION") != ""
243 return useVertex && hasProject && hasLocation
244}
245
246func hasAWSCredentials(env env.Env) bool {
247 if env.Get("AWS_ACCESS_KEY_ID") != "" && env.Get("AWS_SECRET_ACCESS_KEY") != "" {
248 return true
249 }
250
251 if env.Get("AWS_PROFILE") != "" || env.Get("AWS_DEFAULT_PROFILE") != "" {
252 return true
253 }
254
255 if env.Get("AWS_REGION") != "" || env.Get("AWS_DEFAULT_REGION") != "" {
256 return true
257 }
258
259 if env.Get("AWS_CONTAINER_CREDENTIALS_RELATIVE_URI") != "" ||
260 env.Get("AWS_CONTAINER_CREDENTIALS_FULL_URI") != "" {
261 return true
262 }
263
264 return false
265}
266
267func (cfg *Config) setDefaults(workingDir string) {
268 cfg.workingDir = workingDir
269 if cfg.Options == nil {
270 cfg.Options = &Options{}
271 }
272 if cfg.Options.TUI == nil {
273 cfg.Options.TUI = &TUIOptions{}
274 }
275 if cfg.Options.ContextPaths == nil {
276 cfg.Options.ContextPaths = []string{}
277 }
278 if cfg.Options.DataDirectory == "" {
279 cfg.Options.DataDirectory = filepath.Join(workingDir, defaultDataDirectory)
280 }
281 if cfg.Providers == nil {
282 cfg.Providers = make(map[string]ProviderConfig)
283 }
284 if cfg.Models == nil {
285 cfg.Models = make(map[SelectedModelType]SelectedModel)
286 }
287 if cfg.MCP == nil {
288 cfg.MCP = make(map[string]MCPConfig)
289 }
290 if cfg.LSP == nil {
291 cfg.LSP = make(map[string]LSPConfig)
292 }
293
294 // Add the default context paths if they are not already present
295 cfg.Options.ContextPaths = append(defaultContextPaths, cfg.Options.ContextPaths...)
296 slices.Sort(cfg.Options.ContextPaths)
297 cfg.Options.ContextPaths = slices.Compact(cfg.Options.ContextPaths)
298}
299
300func loadFromConfigPaths(configPaths []string) (*Config, error) {
301 var configs []io.Reader
302
303 for _, path := range configPaths {
304 fd, err := os.Open(path)
305 if err != nil {
306 if os.IsNotExist(err) {
307 continue
308 }
309 return nil, fmt.Errorf("failed to open config file %s: %w", path, err)
310 }
311 defer fd.Close()
312
313 configs = append(configs, fd)
314 }
315
316 return loadFromReaders(configs)
317}
318
319func loadFromReaders(readers []io.Reader) (*Config, error) {
320 if len(readers) == 0 {
321 return nil, fmt.Errorf("no configuration readers provided")
322 }
323
324 merged, err := Merge(readers)
325 if err != nil {
326 return nil, fmt.Errorf("failed to merge configuration readers: %w", err)
327 }
328
329 return LoadReader(merged)
330}
331
332func globalConfig() string {
333 xdgConfigHome := os.Getenv("XDG_CONFIG_HOME")
334 if xdgConfigHome != "" {
335 return filepath.Join(xdgConfigHome, "crush")
336 }
337
338 // return the path to the main config directory
339 // for windows, it should be in `%LOCALAPPDATA%/crush/`
340 // for linux and macOS, it should be in `$HOME/.config/crush/`
341 if runtime.GOOS == "windows" {
342 localAppData := os.Getenv("LOCALAPPDATA")
343 if localAppData == "" {
344 localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
345 }
346 return filepath.Join(localAppData, appName)
347 }
348
349 return filepath.Join(os.Getenv("HOME"), ".config", appName, fmt.Sprintf("%s.json", appName))
350}
351
352// globalConfigData returns the path to the main data directory for the application.
353// this config is used when the app overrides configurations instead of updating the global config.
354func globalConfigData() string {
355 xdgDataHome := os.Getenv("XDG_DATA_HOME")
356 if xdgDataHome != "" {
357 return filepath.Join(xdgDataHome, appName)
358 }
359
360 // return the path to the main data directory
361 // for windows, it should be in `%LOCALAPPDATA%/crush/`
362 // for linux and macOS, it should be in `$HOME/.local/share/crush/`
363 if runtime.GOOS == "windows" {
364 localAppData := os.Getenv("LOCALAPPDATA")
365 if localAppData == "" {
366 localAppData = filepath.Join(os.Getenv("USERPROFILE"), "AppData", "Local")
367 }
368 return filepath.Join(localAppData, appName)
369 }
370
371 return filepath.Join(os.Getenv("HOME"), ".local", "share", appName, fmt.Sprintf("%s.json", appName))
372}