@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/settings/manager.js

@@ -0,0 +1,187 @@
+/**
+ * Settings manager — multi-source loading and merge.
+ *
+ * Priority: CLI flags > local > project > user > managed
+ */
+import { readFileSync, existsSync, mkdirSync, writeFileSync, renameSync, copyFileSync, } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { validateSettings } from "./schema.js";
+import { migrateModels } from "../migrate-models.js";
+/**
+ * Resolve the user's home directory. Prefers `process.env.HOME` so that
+ * runtime env overrides (set after process start, e.g. in tests) actually
+ * take effect — on some runtimes (e.g. Bun on macOS) `os.homedir()` is
+ * cached from the user database at process startup and ignores later
+ * `process.env.HOME` mutations.
+ */
+function userHome() {
+    return process.env.HOME ?? homedir();
+}
+export class SettingsManager {
+    cwd;
+    sources = [];
+    merged = null;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    /**
+     * Load settings from all sources.
+     */
+    load(flagOverrides) {
+        this.sources = [];
+        // 1. Managed (lowest priority)
+        this.loadJsonFile(join(userHome(), ".code-shell", "settings.managed.json"), "managed", 0);
+        // 2. User — only ~/.code-shell/. We used to also read ~/.claude/settings.json
+        // for "zero-migration from Claude Code", but Claude Code's schema diverges
+        // (e.g. `model` is a string there, an object here). Merging caused boot
+        // crashes on machines that had Claude Code installed but never ran us.
+        // File-level compat (CLAUDE.md, .claude/skills/) is kept elsewhere — only
+        // the settings.json read is dropped.
+        this.loadJsonFile(join(userHome(), ".code-shell", "settings.json"), "user", 1);
+        // 3. Project
+        this.loadJsonFile(join(this.cwd, ".code-shell", "settings.json"), "project", 2);
+        // 4. Local
+        this.loadJsonFile(join(this.cwd, ".code-shell", "settings.local.json"), "local", 3);
+        // 5. CLI flags (highest priority)
+        if (flagOverrides && Object.keys(flagOverrides).length > 0) {
+            this.sources.push({ name: "flag", priority: 4, data: flagOverrides });
+        }
+        // Sort by priority ascending (merge in order, later wins)
+        this.sources.sort((a, b) => a.priority - b.priority);
+        // Deep merge
+        const raw = this.deepMerge();
+        // Auto-migrate legacy models[] in the user settings file. Runs directly
+        // on the user-scope file (not the merged result), because the merge
+        // collapses provenance and the migration needs to write back to a
+        // single physical file.
+        const userPath = join(userHome(), ".code-shell", "settings.json");
+        if (existsSync(userPath)) {
+            try {
+                const userRaw = JSON.parse(readFileSync(userPath, "utf-8"));
+                const result = migrateModels({
+                    providers: userRaw.providers ?? [],
+                    models: userRaw.models ?? [],
+                });
+                if (result.changed) {
+                    copyFileSync(userPath, `${userPath}.bak`);
+                    const migrated = {
+                        ...userRaw,
+                        providers: result.providers,
+                        models: result.models,
+                    };
+                    writeFileSync(userPath, JSON.stringify(migrated, null, 2), "utf-8");
+                    // Re-deep-merge with the migrated user data so the validate
+                    // call sees the new shape rather than the legacy one.
+                    const userSource = this.sources.find((s) => s.name === "user");
+                    if (userSource)
+                        userSource.data = migrated;
+                    const remerged = this.deepMerge();
+                    this.merged = validateSettings(remerged);
+                    return this.merged;
+                }
+            }
+            catch {
+                // Migration is best-effort — fall through to normal validate.
+            }
+        }
+        this.merged = validateSettings(raw);
+        return this.merged;
+    }
+    /**
+     * Get current effective settings.
+     */
+    get() {
+        if (!this.merged)
+            return this.load();
+        return this.merged;
+    }
+    /**
+     * Invalidate cached merge.
+     */
+    invalidate() {
+        this.merged = null;
+    }
+    /**
+     * Persist a single setting (dotted key path) to the user-level config file
+     * at ~/.code-shell/settings.json. Other sources (project / local /
+     * managed) are intentionally untouched: writing back to project/local
+     * would surprise version control, and managed is read-only.
+     *
+     * The merged cache is invalidated so the next get() picks up the change.
+     */
+    saveUserSetting(key, value) {
+        const path = join(userHome(), ".code-shell", "settings.json");
+        let current = {};
+        if (existsSync(path)) {
+            try {
+                const raw = readFileSync(path, "utf-8");
+                const parsed = JSON.parse(raw);
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    current = parsed;
+                }
+            }
+            catch {
+                // Corrupt file — overwrite rather than crash.
+            }
+        }
+        const parts = key.split(".");
+        let target = current;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const seg = parts[i];
+            const next = target[seg];
+            if (!next || typeof next !== "object" || Array.isArray(next)) {
+                target[seg] = {};
+            }
+            target = target[seg];
+        }
+        target[parts[parts.length - 1]] = value;
+        mkdirSync(dirname(path), { recursive: true });
+        // Atomic write: stage to .tmp, then rename, so a concurrent read can't
+        // catch a half-written file.
+        const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, JSON.stringify(current, null, 2), "utf-8");
+        renameSync(tmp, path);
+        this.invalidate();
+    }
+    loadJsonFile(path, name, priority) {
+        if (!existsSync(path))
+            return;
+        try {
+            const content = readFileSync(path, "utf-8");
+            const data = JSON.parse(content);
+            if (typeof data === "object" && data !== null) {
+                this.sources.push({ name, priority, data });
+            }
+        }
+        catch {
+            // Skip invalid files
+        }
+    }
+    deepMerge() {
+        let result = {};
+        for (const source of this.sources) {
+            result = merge(result, source.data);
+        }
+        return result;
+    }
+}
+function merge(base, override) {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (value === null) {
+            delete result[key];
+        }
+        else if (typeof value === "object" &&
+            !Array.isArray(value) &&
+            typeof result[key] === "object" &&
+            !Array.isArray(result[key]) &&
+            result[key] !== null) {
+            result[key] = merge(result[key], value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}