@sammorrowdrums/mcpi 0.70.9 → 0.85.0

package/dist/core/settings-manager.js

@@ -1,39 +1,50 @@
+import { randomUUID } from "crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
 import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
-/** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
-function deepMergeSettings(base, overrides) {
+import { normalizePath, resolvePath } from "../utils/paths.js";
+import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-dispatcher.js";
+function isMergeableObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMergeObjects(base, overrides) {
     const result = { ...base };
     for (const key of Object.keys(overrides)) {
         const overrideValue = overrides[key];
-        const baseValue = base[key];
         if (overrideValue === undefined) {
             continue;
         }
-        // For nested objects, merge recursively
-        if (typeof overrideValue === "object" &&
-            overrideValue !== null &&
-            !Array.isArray(overrideValue) &&
-            typeof baseValue === "object" &&
-            baseValue !== null &&
-            !Array.isArray(baseValue)) {
-            result[key] = { ...baseValue, ...overrideValue };
-        }
-        else {
-            // For primitives and arrays, override value wins
-            result[key] = overrideValue;
-        }
+        const baseValue = base[key];
+        result[key] =
+            isMergeableObject(baseValue) && isMergeableObject(overrideValue)
+                ? deepMergeObjects(baseValue, overrideValue)
+                : overrideValue;
     }
     return result;
 }
+/** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
+function deepMergeSettings(base, overrides) {
+    return deepMergeObjects(base, overrides);
+}
+function parseTimeoutSetting(value, settingName) {
+    const timeoutMs = parseHttpIdleTimeoutMs(value);
+    if (timeoutMs !== undefined) {
+        return timeoutMs;
+    }
+    if (value !== undefined) {
+        throw new Error(`Invalid ${settingName} setting: ${String(value)}`);
+    }
+    return undefined;
+}
 export class FileSettingsStorage {
     globalSettingsPath;
     projectSettingsPath;
     constructor(cwd, agentDir) {
-        this.globalSettingsPath = join(agentDir, "settings.json");
-        this.projectSettingsPath = join(cwd, CONFIG_DIR_NAME, "settings.json");
+        const resolvedCwd = resolvePath(cwd);
+        const resolvedAgentDir = resolvePath(agentDir);
+        this.globalSettingsPath = join(resolvedAgentDir, "settings.json");
+        this.projectSettingsPath = join(resolvedCwd, CONFIG_DIR_NAME, "settings.json");
     }
     acquireLockSyncWithRetry(path) {
         const maxAttempts = 10;
@@ -110,6 +121,7 @@ export class SettingsManager {
     globalSettings;
     projectSettings;
     settings;
+    projectTrusted;
     modifiedFields = new Set(); // Track global fields modified during session
     modifiedNestedFields = new Map(); // Track global nested field modifications
     modifiedProjectFields = new Set(); // Track project fields modified during session
@@ -118,24 +130,26 @@ export class SettingsManager {
     projectSettingsLoadError = null; // Track if project settings file had parse errors
     writeQueue = Promise.resolve();
     errors;
-    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = []) {
+    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true) {
         this.storage = storage;
         this.globalSettings = initialGlobal;
         this.projectSettings = initialProject;
+        this.projectTrusted = projectTrusted;
         this.globalSettingsLoadError = globalLoadError;
         this.projectSettingsLoadError = projectLoadError;
         this.errors = [...initialErrors];
         this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
     }
     /** Create a SettingsManager that loads from files */
-    static create(cwd, agentDir = getAgentDir()) {
+    static create(cwd, agentDir = getAgentDir(), options = {}) {
         const storage = new FileSettingsStorage(cwd, agentDir);
-        return SettingsManager.fromStorage(storage);
+        return SettingsManager.fromStorage(storage, options);
     }
     /** Create a SettingsManager from an arbitrary storage backend */
-    static fromStorage(storage) {
+    static fromStorage(storage, options = {}) {
+        const projectTrusted = options.projectTrusted ?? true;
         const globalLoad = SettingsManager.tryLoadFromStorage(storage, "global");
-        const projectLoad = SettingsManager.tryLoadFromStorage(storage, "project");
+        const projectLoad = SettingsManager.tryLoadFromStorage(storage, "project", projectTrusted);
         const initialErrors = [];
         if (globalLoad.error) {
             initialErrors.push({ scope: "global", error: globalLoad.error });
@@ -143,16 +157,19 @@ export class SettingsManager {
         if (projectLoad.error) {
             initialErrors.push({ scope: "project", error: projectLoad.error });
         }
-        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors);
+        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted);
     }
     /** Create an in-memory SettingsManager (no file I/O) */
-    static inMemory(settings = {}) {
+    static inMemory(settings = {}, options = {}) {
         const storage = new InMemorySettingsStorage();
         const initialSettings = SettingsManager.migrateSettings(structuredClone(settings));
         storage.withLock("global", () => JSON.stringify(initialSettings, null, 2));
-        return SettingsManager.fromStorage(storage);
+        return SettingsManager.fromStorage(storage, options);
     }
-    static loadFromStorage(storage, scope) {
+    static loadFromStorage(storage, scope, projectTrusted = true) {
+        if (scope === "project" && !projectTrusted) {
+            return {};
+        }
         let content;
         storage.withLock(scope, (current) => {
             content = current;
@@ -164,9 +181,9 @@ export class SettingsManager {
         const settings = JSON.parse(content);
         return SettingsManager.migrateSettings(settings);
     }
-    static tryLoadFromStorage(storage, scope) {
+    static tryLoadFromStorage(storage, scope, projectTrusted = true) {
         try {
-            return { settings: SettingsManager.loadFromStorage(storage, scope), error: null };
+            return { settings: SettingsManager.loadFromStorage(storage, scope, projectTrusted), error: null };
         }
         catch (error) {
             return { settings: {}, error: error };
@@ -200,6 +217,24 @@ export class SettingsManager {
                 delete settings.skills;
             }
         }
+        // Migrate retry.maxDelayMs -> retry.provider.maxRetryDelayMs
+        if ("retry" in settings &&
+            typeof settings.retry === "object" &&
+            settings.retry !== null &&
+            !Array.isArray(settings.retry)) {
+            const retrySettings = settings.retry;
+            const providerSettings = typeof retrySettings.provider === "object" && retrySettings.provider !== null
+                ? retrySettings.provider
+                : undefined;
+            if (typeof retrySettings.maxDelayMs === "number" &&
+                (providerSettings?.maxRetryDelayMs === undefined || providerSettings?.maxRetryDelayMs === null)) {
+                retrySettings.provider = {
+                    ...(providerSettings ?? {}),
+                    maxRetryDelayMs: retrySettings.maxDelayMs,
+                };
+            }
+            delete retrySettings.maxDelayMs;
+        }
         return settings;
     }
     getGlobalSettings() {
@@ -208,6 +243,30 @@ export class SettingsManager {
     getProjectSettings() {
         return structuredClone(this.projectSettings);
     }
+    isProjectTrusted() {
+        return this.projectTrusted;
+    }
+    setProjectTrusted(trusted) {
+        if (this.projectTrusted === trusted) {
+            return;
+        }
+        this.projectTrusted = trusted;
+        this.modifiedProjectFields.clear();
+        this.modifiedProjectNestedFields.clear();
+        if (!trusted) {
+            this.projectSettings = {};
+            this.projectSettingsLoadError = null;
+            this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
+            return;
+        }
+        const projectLoad = SettingsManager.tryLoadFromStorage(this.storage, "project", trusted);
+        this.projectSettings = projectLoad.settings;
+        this.projectSettingsLoadError = projectLoad.error;
+        if (projectLoad.error) {
+            this.recordError("project", projectLoad.error);
+        }
+        this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
+    }
     async reload() {
         await this.writeQueue;
         const globalLoad = SettingsManager.tryLoadFromStorage(this.storage, "global");
@@ -223,7 +282,7 @@ export class SettingsManager {
         this.modifiedNestedFields.clear();
         this.modifiedProjectFields.clear();
         this.modifiedProjectNestedFields.clear();
-        const projectLoad = SettingsManager.tryLoadFromStorage(this.storage, "project");
+        const projectLoad = SettingsManager.tryLoadFromStorage(this.storage, "project", this.projectTrusted);
         if (!projectLoad.error) {
             this.projectSettings = projectLoad.settings;
             this.projectSettingsLoadError = null;
@@ -258,6 +317,11 @@ export class SettingsManager {
             this.modifiedProjectNestedFields.get(field).add(nestedKey);
         }
     }
+    assertProjectTrustedForWrite() {
+        if (!this.projectTrusted) {
+            throw new Error("Project is not trusted; refusing to write project settings");
+        }
+    }
     recordError(scope, error) {
         const normalizedError = error instanceof Error ? error : new Error(String(error));
         this.errors.push({ scope, error: normalizedError });
@@ -274,6 +338,9 @@ export class SettingsManager {
     enqueueWrite(scope, task) {
         this.writeQueue = this.writeQueue
             .then(() => {
+            if (scope === "project") {
+                this.assertProjectTrustedForWrite();
+            }
             task();
             this.clearModifiedScope(scope);
         })
@@ -326,6 +393,7 @@ export class SettingsManager {
         });
     }
     saveProjectSettings(settings) {
+        this.assertProjectTrustedForWrite();
         this.projectSettings = structuredClone(settings);
         this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
         if (this.projectSettingsLoadError) {
@@ -338,6 +406,13 @@ export class SettingsManager {
             this.persistScopedSettings("project", snapshotProjectSettings, modifiedFields, modifiedNestedFields);
         });
     }
+    updateProjectSettings(field, update) {
+        this.assertProjectTrustedForWrite();
+        const projectSettings = structuredClone(this.projectSettings);
+        update(projectSettings);
+        this.markProjectModified(field);
+        this.saveProjectSettings(projectSettings);
+    }
     async flush() {
         await this.writeQueue;
     }
@@ -356,16 +431,7 @@ export class SettingsManager {
     }
     getSessionDir() {
         const sessionDir = this.settings.sessionDir;
-        if (!sessionDir) {
-            return sessionDir;
-        }
-        if (sessionDir === "~") {
-            return homedir();
-        }
-        if (sessionDir.startsWith("~/")) {
-            return join(homedir(), sessionDir.slice(2));
-        }
-        return sessionDir;
+        return sessionDir ? normalizePath(sessionDir) : sessionDir;
     }
     getDefaultProvider() {
         return this.settings.defaultProvider;
@@ -406,8 +472,15 @@ export class SettingsManager {
         this.markModified("followUpMode");
         this.save();
     }
+    getThemeSetting() {
+        const value = this.settings.theme;
+        if (typeof value === "string")
+            return value;
+        return undefined;
+    }
     getTheme() {
-        return this.settings.theme;
+        const theme = this.getThemeSetting();
+        return theme?.includes("/") ? undefined : theme;
     }
     setTheme(theme) {
         this.globalSettings.theme = theme;
@@ -423,7 +496,7 @@ export class SettingsManager {
         this.save();
     }
     getTransport() {
-        return this.settings.transport ?? "sse";
+        return this.settings.transport ?? "auto";
     }
     setTransport(transport) {
         this.globalSettings.transport = transport;
@@ -479,19 +552,59 @@ export class SettingsManager {
             enabled: this.getRetryEnabled(),
             maxRetries: this.settings.retry?.maxRetries ?? 3,
             baseDelayMs: this.settings.retry?.baseDelayMs ?? 2000,
-            maxDelayMs: this.settings.retry?.maxDelayMs ?? 60000,
         };
     }
+    getHttpIdleTimeoutMs() {
+        return parseTimeoutSetting(this.settings.httpIdleTimeoutMs, "httpIdleTimeoutMs") ?? DEFAULT_HTTP_IDLE_TIMEOUT_MS;
+    }
+    setHttpIdleTimeoutMs(timeoutMs) {
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+            throw new Error(`Invalid httpIdleTimeoutMs setting: ${String(timeoutMs)}`);
+        }
+        this.globalSettings.httpIdleTimeoutMs = Math.floor(timeoutMs);
+        this.markModified("httpIdleTimeoutMs");
+        this.save();
+    }
+    getProviderRetrySettings() {
+        return {
+            timeoutMs: this.settings.retry?.provider?.timeoutMs,
+            maxRetries: this.settings.retry?.provider?.maxRetries,
+            maxRetryDelayMs: this.settings.retry?.provider?.maxRetryDelayMs ?? 60000,
+        };
+    }
+    getWebSocketConnectTimeoutMs() {
+        return parseTimeoutSetting(this.settings.websocketConnectTimeoutMs, "websocketConnectTimeoutMs");
+    }
     getHideThinkingBlock() {
         return this.settings.hideThinkingBlock ?? false;
     }
+    getShowCacheMissNotices() {
+        return this.settings.showCacheMissNotices ?? false;
+    }
+    getExternalEditorCommand() {
+        const configuredEditor = this.settings.externalEditor;
+        if (typeof configuredEditor === "string" && configuredEditor.trim() !== "") {
+            return configuredEditor;
+        }
+        const environmentEditor = process.env.VISUAL || process.env.EDITOR;
+        if (environmentEditor) {
+            return environmentEditor;
+        }
+        return process.platform === "win32" ? "notepad" : "nano";
+    }
     setHideThinkingBlock(hide) {
         this.globalSettings.hideThinkingBlock = hide;
         this.markModified("hideThinkingBlock");
         this.save();
     }
+    setShowCacheMissNotices(show) {
+        this.globalSettings.showCacheMissNotices = show;
+        this.markModified("showCacheMissNotices");
+        this.save();
+    }
     getShellPath() {
-        return this.settings.shellPath;
+        const shellPath = this.settings.shellPath;
+        return shellPath ? normalizePath(shellPath) : shellPath;
     }
     setShellPath(path) {
         this.globalSettings.shellPath = path;
@@ -506,6 +619,15 @@ export class SettingsManager {
         this.markModified("quietStartup");
         this.save();
     }
+    getDefaultProjectTrust() {
+        const value = this.globalSettings.defaultProjectTrust;
+        return value === "always" || value === "never" ? value : "ask";
+    }
+    setDefaultProjectTrust(defaultProjectTrust) {
+        this.globalSettings.defaultProjectTrust = defaultProjectTrust;
+        this.markModified("defaultProjectTrust");
+        this.save();
+    }
     getShellCommandPrefix() {
         return this.settings.shellCommandPrefix;
     }
@@ -538,6 +660,22 @@ export class SettingsManager {
         this.markModified("enableInstallTelemetry");
         this.save();
     }
+    getEnableAnalytics() {
+        return this.settings.enableAnalytics ?? false;
+    }
+    getTrackingId() {
+        return this.settings.trackingId;
+    }
+    /** Set the analytics opt-in preference; generates a tracking identifier on first opt-in */
+    setEnableAnalytics(enabled) {
+        this.globalSettings.enableAnalytics = enabled;
+        this.markModified("enableAnalytics");
+        if (enabled && !this.globalSettings.trackingId) {
+            this.globalSettings.trackingId = randomUUID();
+            this.markModified("trackingId");
+        }
+        this.save();
+    }
     getPackages() {
         return [...(this.settings.packages ?? [])];
     }
@@ -547,10 +685,9 @@ export class SettingsManager {
         this.save();
     }
     setProjectPackages(packages) {
-        const projectSettings = structuredClone(this.projectSettings);
-        projectSettings.packages = packages;
-        this.markProjectModified("packages");
-        this.saveProjectSettings(projectSettings);
+        this.updateProjectSettings("packages", (settings) => {
+            settings.packages = packages;
+        });
     }
     getExtensionPaths() {
         return [...(this.settings.extensions ?? [])];
@@ -561,10 +698,9 @@ export class SettingsManager {
         this.save();
     }
     setProjectExtensionPaths(paths) {
-        const projectSettings = structuredClone(this.projectSettings);
-        projectSettings.extensions = paths;
-        this.markProjectModified("extensions");
-        this.saveProjectSettings(projectSettings);
+        this.updateProjectSettings("extensions", (settings) => {
+            settings.extensions = paths;
+        });
     }
     getSkillPaths() {
         return [...(this.settings.skills ?? [])];
@@ -575,10 +711,9 @@ export class SettingsManager {
         this.save();
     }
     setProjectSkillPaths(paths) {
-        const projectSettings = structuredClone(this.projectSettings);
-        projectSettings.skills = paths;
-        this.markProjectModified("skills");
-        this.saveProjectSettings(projectSettings);
+        this.updateProjectSettings("skills", (settings) => {
+            settings.skills = paths;
+        });
     }
     getPromptTemplatePaths() {
         return [...(this.settings.prompts ?? [])];
@@ -589,10 +724,9 @@ export class SettingsManager {
         this.save();
     }
     setProjectPromptTemplatePaths(paths) {
-        const projectSettings = structuredClone(this.projectSettings);
-        projectSettings.prompts = paths;
-        this.markProjectModified("prompts");
-        this.saveProjectSettings(projectSettings);
+        this.updateProjectSettings("prompts", (settings) => {
+            settings.prompts = paths;
+        });
     }
     getThemePaths() {
         return [...(this.settings.themes ?? [])];
@@ -603,10 +737,9 @@ export class SettingsManager {
         this.save();
     }
     setProjectThemePaths(paths) {
-        const projectSettings = structuredClone(this.projectSettings);
-        projectSettings.themes = paths;
-        this.markProjectModified("themes");
-        this.saveProjectSettings(projectSettings);
+        this.updateProjectSettings("themes", (settings) => {
+            settings.themes = paths;
+        });
     }
     getEnableSkillCommands() {
         return this.settings.enableSkillCommands ?? true;
@@ -650,7 +783,7 @@ export class SettingsManager {
         if (this.settings.terminal?.clearOnShrink !== undefined) {
             return this.settings.terminal.clearOnShrink;
         }
-        return process.env.PI_CLEAR_ON_SHRINK === "1";
+        return process.env.MCPI_CLEAR_ON_SHRINK === "1";
     }
     setClearOnShrink(enabled) {
         if (!this.globalSettings.terminal) {
@@ -671,6 +804,31 @@ export class SettingsManager {
         this.markModified("terminal", "showTerminalProgress");
         this.save();
     }
+    getTuiMode() {
+        return this.settings.tuiMode === "fullscreen" ? "fullscreen" : "regular";
+    }
+    setTuiMode(mode) {
+        this.globalSettings.tuiMode = mode;
+        this.markModified("tuiMode");
+        this.save();
+    }
+    getFullscreenExitOutput() {
+        return this.settings.fullscreenExitOutput === "resume-hint" ? "resume-hint" : "transcript";
+    }
+    setFullscreenExitOutput(output) {
+        this.globalSettings.fullscreenExitOutput = output;
+        this.markModified("fullscreenExitOutput");
+        this.save();
+    }
+    getFullscreenScrollbar() {
+        const mode = this.settings.fullscreenScrollbar;
+        return mode === "always" || mode === "hidden" ? mode : "auto";
+    }
+    setFullscreenScrollbar(mode) {
+        this.globalSettings.fullscreenScrollbar = mode;
+        this.markModified("fullscreenScrollbar");
+        this.save();
+    }
     getImageAutoResize() {
         return this.settings.images?.autoResize ?? true;
     }
@@ -696,6 +854,10 @@ export class SettingsManager {
     getEnabledModels() {
         return this.settings.enabledModels;
     }
+    getDefaultTools() {
+        const tools = this.settings.defaultTools;
+        return tools ? [...tools] : undefined;
+    }
     setEnabledModels(patterns) {
         this.globalSettings.enabledModels = patterns;
         this.markModified("enabledModels");
@@ -720,7 +882,7 @@ export class SettingsManager {
         this.save();
     }
     getShowHardwareCursor() {
-        return this.settings.showHardwareCursor ?? process.env.PI_HARDWARE_CURSOR === "1";
+        return this.settings.showHardwareCursor ?? process.env.MCPI_HARDWARE_CURSOR === "1";
     }
     setShowHardwareCursor(enabled) {
         this.globalSettings.showHardwareCursor = enabled;
@@ -735,6 +897,14 @@ export class SettingsManager {
         this.markModified("editorPaddingX");
         this.save();
     }
+    getOutputPad() {
+        return this.settings.outputPad === 0 ? 0 : 1;
+    }
+    setOutputPad(padding) {
+        this.globalSettings.outputPad = padding;
+        this.markModified("outputPad");
+        this.save();
+    }
     getAutocompleteMaxVisible() {
         return this.settings.autocompleteMaxVisible ?? 5;
     }
@@ -746,5 +916,23 @@ export class SettingsManager {
     getCodeBlockIndent() {
         return this.settings.markdown?.codeBlockIndent ?? "  ";
     }
+    getMermaidRenderingMode() {
+        const mode = this.settings.markdown?.mermaid;
+        return mode === "off" || mode === "final" ? mode : "streaming";
+    }
+    setMermaidRenderingMode(mode) {
+        this.globalSettings.markdown ??= {};
+        this.globalSettings.markdown.mermaid = mode;
+        this.markModified("markdown", "mermaid");
+        this.save();
+    }
+    getWarnings() {
+        return { ...(this.settings.warnings ?? {}) };
+    }
+    setWarnings(warnings) {
+        this.globalSettings.warnings = { ...warnings };
+        this.markModified("warnings");
+        this.save();
+    }
 }
 //# sourceMappingURL=settings-manager.js.map