xonecas.io
7814
Ta

tiny-c-agent / files

tiny-c-agent / src / config.c

15.8 KB
1#include "config.h"
2
3#include <errno.h>
4#include <limits.h>
5#include <stdarg.h>
6#include <stdio.h>
7#include <stdlib.h>
8#include <string.h>
9#include <sys/stat.h>
10#include <unistd.h>
11
12#include <yyjson.h>
13
14#include "util.h"
15
16#define READ_FLAGS (YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS)
17
18// A config value the user has not written yet. The partial form keeps every
19// field optional so a local config only overrides the keys it sets.
20typedef struct {
21    int theme;                  // -1 unset, otherwise a tiny_theme.
22    char *provider;
23    char *model;
24    char *effort;
25    char *system_prompt;
26    int discover_agent_files;   // -1 unset, otherwise a bool.
27    char **skills_dirs;
28    size_t skills_dirs_len;
29    bool skills_dirs_set;
30    char *sessions_dir;
31    tiny_provider *custom_providers;
32    size_t custom_providers_len;
33    bool custom_providers_set;
34} partial;
35
36static int fail(char **err, const char *path, const char *fmt, ...) {
37    char detail[256];
38    va_list ap;
39    va_start(ap, fmt);
40    vsnprintf(detail, sizeof detail, fmt, ap);
41    va_end(ap);
42    size_t n = strlen(path) + strlen(detail) + 16;
43    char *msg = xmalloc(n);
44    snprintf(msg, n, "config %s: %s", path, detail);
45    free(*err);
46    *err = msg;
47    return -1;
48}
49
50static char *config_file_path(void) {
51    const char *base = getenv("XDG_CONFIG_HOME");
52    char *dir;
53    if (base && base[0]) {
54        dir = tiny_path_join(base, "tiny");
55    } else {
56        const char *home = getenv("HOME");
57        if (!home || !home[0]) return NULL;
58        dir = tiny_path_join(home, ".config/tiny");
59    }
60    char *p = tiny_path_join(dir, "config.json");
61    free(dir);
62    return p;
63}
64
65static char *default_sessions_dir(void) {
66    const char *state = getenv("XDG_STATE_HOME");
67    if (state && state[0]) return tiny_path_join(state, "tiny/sessions");
68    const char *home = getenv("HOME");
69    if (home && home[0]) return tiny_path_join(home, ".local/state/tiny/sessions");
70    return xstrdup("sessions");
71}
72
73static bool valid_effort(const char *s) {
74    static const char *const values[] = {
75        "off", "minimal", "low", "medium", "high", "xhigh", "max",
76    };
77    for (size_t i = 0; i < sizeof values / sizeof values[0]; i++)
78        if (strcmp(s, values[i]) == 0) return true;
79    return false;
80}
81
82static bool parse_api(const char *s, tiny_api *out) {
83    if (strcmp(s, "openai-completions") == 0) *out = TINY_API_OPENAI_COMPLETIONS;
84    else if (strcmp(s, "openai-responses") == 0) *out = TINY_API_OPENAI_RESPONSES;
85    else if (strcmp(s, "anthropic-messages") == 0) *out = TINY_API_ANTHROPIC_MESSAGES;
86    else if (strcmp(s, "google-generative-ai") == 0) *out = TINY_API_GOOGLE_GENERATIVE_AI;
87    else return false;
88    return true;
89}
90
91// Copies an optional string field. Absent leaves *out untouched.
92static int opt_str(yyjson_val *obj, const char *key, char **out,
93                   const char *path, char **err) {
94    yyjson_val *v = yyjson_obj_get(obj, key);
95    if (!v) return 0;
96    if (!yyjson_is_str(v)) return fail(err, path, "\"%s\" must be a string", key);
97    *out = xstrdup(yyjson_get_str(v));
98    return 0;
99}
100
101static int opt_bool(yyjson_val *obj, const char *key, int *out,
102                    const char *path, char **err) {
103    yyjson_val *v = yyjson_obj_get(obj, key);
104    if (!v) return 0;
105    if (!yyjson_is_bool(v)) return fail(err, path, "\"%s\" must be a boolean", key);
106    *out = yyjson_get_bool(v);
107    return 0;
108}
109
110static int parse_str_array(yyjson_val *v, const char *key,
111                           char ***out, size_t *out_len,
112                           const char *path, char **err) {
113    if (!yyjson_is_arr(v)) return fail(err, path, "\"%s\" must be an array", key);
114    size_t idx, max;
115    yyjson_val *e;
116    yyjson_arr_foreach(v, idx, max, e) {
117        if (!yyjson_is_str(e))
118            return fail(err, path, "\"%s[%zu]\" must be a string", key, idx);
119        *out = xrealloc(*out, (*out_len + 1) * sizeof **out);
120        (*out)[(*out_len)++] = xstrdup(yyjson_get_str(e));
121    }
122    return 0;
123}
124
125static void provider_free(tiny_provider *p) {
126    free(p->id);
127    free(p->name);
128    free(p->base_url);
129    for (size_t i = 0; i < p->models_len; i++) free(p->models[i]);
130    free(p->models);
131    memset(p, 0, sizeof *p);
132}
133
134static int parse_provider(yyjson_val *v, size_t idx, const char *path,
135                          tiny_provider *out, char **err) {
136    if (!yyjson_is_obj(v))
137        return fail(err, path, "\"customProviders[%zu]\" must be an object", idx);
138    if (opt_str(v, "id", &out->id, path, err) != 0) return -1;
139    if (!out->id || !out->id[0])
140        return fail(err, path, "\"customProviders[%zu].id\" must be a non-empty string", idx);
141    if (opt_str(v, "name", &out->name, path, err) != 0) return -1;
142    if (opt_str(v, "baseUrl", &out->base_url, path, err) != 0) return -1;
143    if (!out->base_url || !out->base_url[0])
144        return fail(err, path, "\"customProviders[%zu].baseUrl\" must be a non-empty string", idx);
145
146    yyjson_val *api = yyjson_obj_get(v, "api");
147    if (!api || !yyjson_is_str(api))
148        return fail(err, path, "\"customProviders[%zu].api\" must be a string", idx);
149    if (!parse_api(yyjson_get_str(api), &out->api))
150        return fail(err, path, "\"customProviders[%zu].api\" is unknown", idx);
151
152    yyjson_val *models = yyjson_obj_get(v, "models");
153    if (!models || !yyjson_is_arr(models) || yyjson_arr_size(models) == 0)
154        return fail(err, path, "\"customProviders[%zu].models\" must be a non-empty array", idx);
155    if (parse_str_array(models, "models", &out->models, &out->models_len, path, err) != 0)
156        return -1;
157    return 0;
158}
159
160static int parse_partial(yyjson_val *root, const char *path, partial *p, char **err) {
161    if (!yyjson_is_obj(root))
162        return fail(err, path, "root must be an object");
163
164    yyjson_val *v = yyjson_obj_get(root, "theme");
165    if (v) {
166        if (!yyjson_is_str(v)) return fail(err, path, "\"theme\" must be a string");
167        const char *s = yyjson_get_str(v);
168        if (strcmp(s, "tokyo-night") == 0) p->theme = TINY_THEME_TOKYO_NIGHT;
169        else if (strcmp(s, "auto") == 0) p->theme = TINY_THEME_AUTO;
170        else return fail(err, path, "unknown theme \"%s\"", s);
171    }
172
173    if (opt_str(root, "provider", &p->provider, path, err) != 0) return -1;
174    if (opt_str(root, "model", &p->model, path, err) != 0) return -1;
175    if (opt_str(root, "systemPrompt", &p->system_prompt, path, err) != 0) return -1;
176    if (opt_str(root, "sessionsDir", &p->sessions_dir, path, err) != 0) return -1;
177    if (opt_bool(root, "discoverAgentFiles", &p->discover_agent_files, path, err) != 0) return -1;
178
179    v = yyjson_obj_get(root, "effort");
180    if (v) {
181        if (!yyjson_is_str(v)) return fail(err, path, "\"effort\" must be a string");
182        const char *s = yyjson_get_str(v);
183        if (!valid_effort(s)) return fail(err, path, "unknown effort \"%s\"", s);
184        p->effort = xstrdup(s);
185    }
186
187    v = yyjson_obj_get(root, "skillsDirs");
188    if (v) {
189        p->skills_dirs_set = true;
190        if (parse_str_array(v, "skillsDirs", &p->skills_dirs, &p->skills_dirs_len, path, err) != 0)
191            return -1;
192    }
193
194    v = yyjson_obj_get(root, "customProviders");
195    if (v) {
196        p->custom_providers_set = true;
197        if (!yyjson_is_arr(v)) return fail(err, path, "\"customProviders\" must be an array");
198        p->custom_providers = xcalloc(yyjson_arr_size(v), sizeof *p->custom_providers);
199        size_t idx, max;
200        yyjson_val *e;
201        yyjson_arr_foreach(v, idx, max, e) {
202            // Count the slot before filling it, so a parse failure still frees
203            // the fields that were already set.
204            p->custom_providers_len++;
205            if (parse_provider(e, idx, path, &p->custom_providers[p->custom_providers_len - 1], err) != 0)
206                return -1;
207        }
208    }
209    return 0;
210}
211
212static int load_into(const char *path, bool required, partial *p, char **err) {
213    if (!path) return 0;
214    FILE *f = fopen(path, "rb");
215    if (!f) {
216        if (!required && errno == ENOENT) return 0;
217        return fail(err, path, "%s", strerror(errno));
218    }
219    if (fseek(f, 0, SEEK_END) != 0 || ftell(f) < 0) {
220        fclose(f);
221        return fail(err, path, "cannot read file");
222    }
223    long size = ftell(f);
224    rewind(f);
225    char *buf = xmalloc((size_t)size + 1);
226    size_t got = fread(buf, 1, (size_t)size, f);
227    fclose(f);
228    buf[got] = '\0';
229
230    yyjson_doc *doc = yyjson_read(buf, got, READ_FLAGS);
231    free(buf);
232    if (!doc) return fail(err, path, "invalid JSON");
233    int rc = parse_partial(yyjson_doc_get_root(doc), path, p, err);
234    yyjson_doc_free(doc);
235    return rc;
236}
237static void merge_str(char **dst, char **src) {
238    if (!*src) return;
239    free(*dst);
240    *dst = *src;
241    *src = NULL;
242}
243
244static void merge_partial(partial *dst, partial *src) {
245    if (src->theme != -1) dst->theme = src->theme;
246    merge_str(&dst->provider, &src->provider);
247    merge_str(&dst->model, &src->model);
248    merge_str(&dst->effort, &src->effort);
249    merge_str(&dst->system_prompt, &src->system_prompt);
250    merge_str(&dst->sessions_dir, &src->sessions_dir);
251    if (src->discover_agent_files != -1) dst->discover_agent_files = src->discover_agent_files;
252    if (src->skills_dirs_set) {
253        for (size_t i = 0; i < dst->skills_dirs_len; i++) free(dst->skills_dirs[i]);
254        free(dst->skills_dirs);
255        dst->skills_dirs = src->skills_dirs;
256        dst->skills_dirs_len = src->skills_dirs_len;
257        src->skills_dirs = NULL;
258        src->skills_dirs_len = 0;
259    }
260    if (src->custom_providers_set) {
261        for (size_t i = 0; i < dst->custom_providers_len; i++) provider_free(&dst->custom_providers[i]);
262        free(dst->custom_providers);
263        dst->custom_providers = src->custom_providers;
264        dst->custom_providers_len = src->custom_providers_len;
265        src->custom_providers = NULL;
266        src->custom_providers_len = 0;
267        src->custom_providers_set = false;
268    }
269}
270
271static void partial_free(partial *p) {
272    free(p->provider);
273    free(p->model);
274    free(p->effort);
275    free(p->system_prompt);
276    free(p->sessions_dir);
277    for (size_t i = 0; i < p->skills_dirs_len; i++) free(p->skills_dirs[i]);
278    free(p->skills_dirs);
279    for (size_t i = 0; i < p->custom_providers_len; i++) provider_free(&p->custom_providers[i]);
280    free(p->custom_providers);
281}
282
283static void config_free_members(tiny_config *cfg) {
284    free(cfg->provider);
285    free(cfg->model);
286    free(cfg->effort);
287    free(cfg->system_prompt);
288    free(cfg->sessions_dir);
289    for (size_t i = 0; i < cfg->skills_dirs_len; i++) free(cfg->skills_dirs[i]);
290    free(cfg->skills_dirs);
291    for (size_t i = 0; i < cfg->custom_providers_len; i++) provider_free(&cfg->custom_providers[i]);
292    free(cfg->custom_providers);
293}
294
295// The directory part of a path, or "." when there is no separator.
296static char *dir_of(const char *path) {
297    const char *slash = strrchr(path, '/');
298    if (!slash) return xstrdup(".");
299    size_t n = (size_t)(slash - path);
300    if (n == 0) return xstrdup("/");
301    char *d = xmalloc(n + 1);
302    memcpy(d, path, n);
303    d[n] = '\0';
304    return d;
305}
306
307int tiny_config_save(const char *provider, const char *model, const char *effort, char **err) {
308    if (err) *err = NULL;
309    char *path = config_file_path();
310    if (!path) {
311        if (err) *err = xstrdup("cannot locate the global config path");
312        return -1;
313    }
314
315    yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
316    yyjson_mut_val *root = yyjson_mut_obj(doc);
317    yyjson_mut_doc_set_root(doc, root);
318
319    // Carry over every existing key so unrelated settings survive the write.
320    FILE *f = fopen(path, "rb");
321    if (f) {
322        size_t cap = 4096, len = 0;
323        char *text = xmalloc(cap);
324        size_t n;
325        while ((n = fread(text + len, 1, cap - len, f)) > 0) {
326            len += n;
327            if (len == cap) {
328                cap *= 2;
329                text = xrealloc(text, cap);
330            }
331        }
332        fclose(f);
333        yyjson_doc *old = yyjson_read(text, len, READ_FLAGS);
334        free(text);
335        if (old) {
336            yyjson_val *oroot = yyjson_doc_get_root(old);
337            if (yyjson_is_obj(oroot)) {
338                yyjson_obj_iter it = yyjson_obj_iter_with(oroot);
339                yyjson_val *k;
340                while ((k = yyjson_obj_iter_next(&it)) != NULL) {
341                    yyjson_mut_val *mk = yyjson_val_mut_copy(doc, k);
342                    yyjson_mut_val *mv = yyjson_val_mut_copy(doc, yyjson_obj_iter_get_val(k));
343                    yyjson_mut_obj_add(root, mk, mv);
344                }
345            }
346            yyjson_doc_free(old);
347        }
348    }
349
350    struct {
351        const char *key;
352        const char *value;
353    } fields[] = {
354        {"provider", provider},
355        {"model", model},
356        {"effort", effort},
357    };
358    for (size_t i = 0; i < sizeof fields / sizeof fields[0]; i++) {
359        if (!fields[i].value) continue;
360        yyjson_mut_obj_put(root, yyjson_mut_strcpy(doc, fields[i].key),
361                           yyjson_mut_strcpy(doc, fields[i].value));
362    }
363
364    char *body = yyjson_mut_write(doc, YYJSON_WRITE_PRETTY, NULL);
365    yyjson_mut_doc_free(doc);
366    if (!body) {
367        free(path);
368        if (err) *err = xstrdup("cannot serialize config");
369        return -1;
370    }
371
372    char *dir = dir_of(path);
373    if (tiny_mkdirs(dir) != 0) {
374        tiny_set_error(err, "cannot create %s: %s", dir, strerror(errno));
375        free(dir);
376        free(body);
377        free(path);
378        return -1;
379    }
380    free(dir);
381
382    size_t plen = strlen(path);
383    char *temp = xmalloc(plen + 32);
384    snprintf(temp, plen + 32, "%s.%d.tmp", path, (int)getpid());
385    FILE *out = fopen(temp, "wb");
386    if (!out) {
387        tiny_set_error(err, "cannot write %s: %s", path, strerror(errno));
388        free(temp);
389        free(body);
390        free(path);
391        return -1;
392    }
393    int rc = fwrite(body, 1, strlen(body), out) == strlen(body) && fflush(out) == 0 ? 0 : -1;
394    if (fclose(out) != 0) rc = -1;
395    free(body);
396    if (rc != 0) {
397        tiny_set_error(err, "%s", "config write failed");
398        remove(temp);
399        free(temp);
400        free(path);
401        return -1;
402    }
403    if (rename(temp, path) != 0) {
404        tiny_set_error(err, "cannot replace %s: %s", path, strerror(errno));
405        remove(temp);
406        free(temp);
407        free(path);
408        return -1;
409    }
410    free(temp);
411    free(path);
412    return 0;
413}
414
415tiny_config *tiny_config_load(const char *cli_path, char **err) {
416    if (err) *err = NULL;
417
418    partial global = {.theme = -1, .discover_agent_files = -1};
419    partial local = {.theme = -1, .discover_agent_files = -1};
420    char *global_path = config_file_path();
421
422    int rc = load_into(global_path, false, &global, err);
423    free(global_path);
424    if (rc == 0 && cli_path) rc = load_into(cli_path, true, &local, err);
425    if (rc != 0) {
426        partial_free(&global);
427        partial_free(&local);
428        return NULL;
429    }
430    merge_partial(&global, &local);
431
432    tiny_config *cfg = xcalloc(1, sizeof *cfg);
433    cfg->theme = global.theme == -1 ? TINY_THEME_TOKYO_NIGHT : (tiny_theme)global.theme;
434    cfg->provider = global.provider;
435    cfg->model = global.model;
436    cfg->effort = global.effort;
437    cfg->system_prompt = global.system_prompt;
438    cfg->discover_agent_files = global.discover_agent_files == -1 ? true : global.discover_agent_files;
439    cfg->skills_dirs = global.skills_dirs;
440    cfg->skills_dirs_len = global.skills_dirs_len;
441    cfg->sessions_dir = global.sessions_dir ? global.sessions_dir : default_sessions_dir();
442    cfg->custom_providers = global.custom_providers;
443    cfg->custom_providers_len = global.custom_providers_len;
444
445    global.provider = global.model = global.effort = NULL;
446    global.system_prompt = global.sessions_dir = NULL;
447    global.skills_dirs = NULL;
448    global.skills_dirs_len = 0;
449    global.custom_providers = NULL;
450    global.custom_providers_len = 0;
451
452    partial_free(&global);
453    partial_free(&local);
454    return cfg;
455}
456
457void tiny_config_free(tiny_config *cfg) {
458    if (!cfg) return;
459    config_free_members(cfg);
460    free(cfg);
461}