apex-code 0.0.1-alpha.8 → 0.0.4

package/dist/core/settings-manager.js

@@ -3,8 +3,9 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
 import { normalizePath, resolvePath } from "../utils/paths.js";
+import { stripBom } from "../utils/text.js";
 import { getApexEnvironment } from "./environment.js";
-import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-idle-timeout.js";
+import { DEFAULT_HTTP_IDLE_TIMEOUT_MS, parseHttpIdleTimeoutMs } from "./http-dispatcher.js";
 /**
  * `proper-lockfile` is required lazily, not imported: the supervisor loads this module
  * on every launch just to read settings, and a static import puts the lock library
@@ -21,6 +22,32 @@ function lockfile() {
     }
     return lockfileModule;
 }
+/**
+ * Measured run-budget defaults (docs/research/2026-09-02-run-budget-measurements.md,
+ * recorded in the spec before implementation): ~60x the heaviest corpus run and
+ * ~18x the scripted 10-step tool loop for requests; 100 full 20-call batches for
+ * tool calls. No measured basis exists for a wall-time default, so there is none.
+ */
+export const DEFAULT_MAX_PROVIDER_REQUESTS = 200;
+export const DEFAULT_MAX_TOOL_CALLS = 2000;
+/**
+ * Workspace-state artifact defaults (WS.3). A patch cap of 256 KiB covers
+ * typical bounded summaries while keeping artifacts well inside the total
+ * 2 MiB retention budget for 20 retained artifacts.
+ */
+export const DEFAULT_WORKSPACE_MAX_PATCH_BYTES = 256 * 1024;
+export const DEFAULT_WORKSPACE_MAX_ARTIFACTS = 20;
+export const DEFAULT_WORKSPACE_MAX_TOTAL_BYTES = 2 * 1024 * 1024;
+function resolveRunBudgetLimit(value, fallback, name) {
+    if (value === undefined)
+        return fallback;
+    if (value === "unlimited")
+        return undefined;
+    if (typeof value !== "number" || !Number.isInteger(value) || !Number.isFinite(value) || value < 0) {
+        throw new Error(`Invalid ${name} setting: ${String(value)}`);
+    }
+    return value;
+}
 /**
  * Hard ceiling on `delegationMaxDepth`, independent of what a user configures. A
  * placeholder pending real measurement (the open question `docs/plans/2026-08-14-
@@ -62,6 +89,13 @@ function parseTimeoutSetting(value, settingName) {
     }
     return undefined;
 }
+function toSettingsError(scope, error, path) {
+    return {
+        scope,
+        ...(path ? { path } : {}),
+        error: error instanceof Error ? error : new Error(String(error)),
+    };
+}
 export class FileSettingsStorage {
     globalSettingsPath;
     projectSettingsPath;
@@ -155,7 +189,8 @@ 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 = [], projectTrusted = true) {
+    settingsPaths;
+    constructor(storage, initialGlobal, initialProject, globalLoadError = null, projectLoadError = null, initialErrors = [], projectTrusted = true, settingsPaths = {}) {
         this.storage = storage;
         this.globalSettings = initialGlobal;
         this.projectSettings = initialProject;
@@ -163,26 +198,36 @@ export class SettingsManager {
         this.globalSettingsLoadError = globalLoadError;
         this.projectSettingsLoadError = projectLoadError;
         this.errors = [...initialErrors];
+        this.settingsPaths = settingsPaths;
         this.settings = deepMergeSettings(this.globalSettings, this.projectSettings);
     }
     /** Create a SettingsManager that loads from files */
     static create(cwd, agentDir = getAgentDir(), options = {}) {
-        const storage = new FileSettingsStorage(cwd, agentDir);
-        return SettingsManager.fromStorage(storage, options);
+        const resolvedCwd = resolvePath(cwd);
+        const resolvedAgentDir = resolvePath(agentDir);
+        const storage = new FileSettingsStorage(resolvedCwd, resolvedAgentDir);
+        return SettingsManager.fromStorageWithPaths(storage, options, {
+            global: join(resolvedAgentDir, "settings.json"),
+            project: join(resolvedCwd, CONFIG_DIR_NAME, "settings.json"),
+        });
     }
     /** Create a SettingsManager from an arbitrary storage backend */
     static fromStorage(storage, options = {}) {
+        return SettingsManager.fromStorageWithPaths(storage, options);
+    }
+    /** Create a manager while retaining optional file paths for reported storage errors. */
+    static fromStorageWithPaths(storage, options, settingsPaths = {}) {
         const projectTrusted = options.projectTrusted ?? true;
         const globalLoad = SettingsManager.tryLoadFromStorage(storage, "global");
         const projectLoad = SettingsManager.tryLoadFromStorage(storage, "project", projectTrusted);
         const initialErrors = [];
         if (globalLoad.error) {
-            initialErrors.push({ scope: "global", error: globalLoad.error });
+            initialErrors.push(toSettingsError("global", globalLoad.error, settingsPaths.global));
         }
         if (projectLoad.error) {
-            initialErrors.push({ scope: "project", error: projectLoad.error });
+            initialErrors.push(toSettingsError("project", projectLoad.error, settingsPaths.project));
         }
-        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted);
+        return new SettingsManager(storage, globalLoad.settings, projectLoad.settings, globalLoad.error, projectLoad.error, initialErrors, projectTrusted, settingsPaths);
     }
     /** Create an in-memory SettingsManager (no file I/O) */
     static inMemory(settings = {}, options = {}) {
@@ -203,7 +248,7 @@ export class SettingsManager {
         if (!content) {
             return {};
         }
-        const settings = JSON.parse(content);
+        const settings = JSON.parse(stripBom(content));
         return SettingsManager.migrateSettings(settings);
     }
     static tryLoadFromStorage(storage, scope, projectTrusted = true) {
@@ -262,6 +307,15 @@ export class SettingsManager {
         }
         return settings;
     }
+    /** The agent directory this manager loads global settings from, when known. */
+    getAgentDir() {
+        const globalPath = this.settingsPaths.global;
+        return globalPath === undefined ? undefined : dirname(globalPath);
+    }
+    /** Merged policy settings (project replaces user arrays wholesale at this raw layer). */
+    getPolicySettings() {
+        return this.settings.policies;
+    }
     getGlobalSettings() {
         return structuredClone(this.globalSettings);
     }
@@ -348,8 +402,7 @@ export class SettingsManager {
         }
     }
     recordError(scope, error) {
-        const normalizedError = error instanceof Error ? error : new Error(String(error));
-        this.errors.push({ scope, error: normalizedError });
+        this.errors.push(toSettingsError(scope, error, this.settingsPaths[scope]));
     }
     clearModifiedScope(scope) {
         if (scope === "global") {
@@ -383,7 +436,7 @@ export class SettingsManager {
     persistScopedSettings(scope, snapshotSettings, modifiedFields, modifiedNestedFields) {
         this.storage.withLock(scope, (current) => {
             const currentFileSettings = current
-                ? SettingsManager.migrateSettings(JSON.parse(current))
+                ? SettingsManager.migrateSettings(JSON.parse(stripBom(current)))
                 : {};
             const mergedSettings = { ...currentFileSettings };
             for (const field of modifiedFields) {
@@ -528,6 +581,30 @@ export class SettingsManager {
         this.markModified("defaultThinkingLevel");
         this.save();
     }
+    getModelThinkingLevel(provider, modelId) {
+        return this.settings.modelThinkingLevels?.[`${provider}/${modelId}`];
+    }
+    getAllModelThinkingLevels() {
+        return { ...(this.settings.modelThinkingLevels ?? {}) };
+    }
+    setModelThinkingLevel(provider, modelId, level) {
+        if (!this.globalSettings.modelThinkingLevels) {
+            this.globalSettings.modelThinkingLevels = {};
+        }
+        this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`] = level;
+        this.markModified("modelThinkingLevels");
+        this.save();
+    }
+    removeModelThinkingLevel(provider, modelId) {
+        if (!this.globalSettings.modelThinkingLevels)
+            return;
+        delete this.globalSettings.modelThinkingLevels[`${provider}/${modelId}`];
+        if (Object.keys(this.globalSettings.modelThinkingLevels).length === 0) {
+            delete this.globalSettings.modelThinkingLevels;
+        }
+        this.markModified("modelThinkingLevels");
+        this.save();
+    }
     getTransport() {
         return this.settings.transport ?? "auto";
     }
@@ -569,12 +646,21 @@ export class SettingsManager {
     getNetworkSettings() {
         return this.settings.network;
     }
+    getSandboxProfiles() {
+        return this.settings.sandboxProfiles === undefined ? undefined : structuredClone(this.settings.sandboxProfiles);
+    }
     getLspSettings() {
         return this.settings.lsp === undefined ? undefined : structuredClone(this.settings.lsp);
     }
     getWebSearchSettings() {
         return this.settings.webSearch === undefined ? undefined : structuredClone(this.settings.webSearch);
     }
+    getCheckpointSettings() {
+        return this.settings.checkpoints === undefined ? undefined : structuredClone(this.settings.checkpoints);
+    }
+    getHookSettings() {
+        return this.settings.hooks === undefined ? undefined : structuredClone(this.settings.hooks);
+    }
     getBranchSummarySkipPrompt() {
         return this.settings.branchSummary?.skipPrompt ?? false;
     }
@@ -617,6 +703,52 @@ export class SettingsManager {
             maxRetryDelayMs: this.settings.retry?.provider?.maxRetryDelayMs ?? 60000,
         };
     }
+    /**
+     * Resolve the run-budget policy actually enforced by the agent core (spec
+     * 2026-09-01-tool-reliability-and-execution-budgets.md). Absent fields take
+     * the measured defaults; the explicit `"unlimited"` value resolves to
+     * "no limit" for that field; malformed values throw so a broken policy is
+     * rejected before any session runs.
+     */
+    getRunBudget() {
+        const settings = this.settings.runBudget;
+        return {
+            maxProviderRequests: resolveRunBudgetLimit(settings?.maxProviderRequests, DEFAULT_MAX_PROVIDER_REQUESTS, "runBudget.maxProviderRequests"),
+            maxToolCalls: resolveRunBudgetLimit(settings?.maxToolCalls, DEFAULT_MAX_TOOL_CALLS, "runBudget.maxToolCalls"),
+            maxWallTimeMs: resolveRunBudgetLimit(settings?.maxWallTimeMs, undefined, "runBudget.maxWallTimeMs"),
+        };
+    }
+    /**
+     * Resolve the workspace-state policy (spec
+     * 2026-09-01-harness-correctness-and-workspace-state.md § 2). Defaults to
+     * metadata-only capture. Malformed values throw so a broken policy is
+     * rejected before any session runs. The per-artifact cap is clamped to
+     * the total retention cap so a single artifact can never exceed the
+     * whole budget.
+     */
+    getWorkspaceState() {
+        const settings = this.settings.workspaceState;
+        const patchCapture = settings?.patchCapture ?? "off";
+        if (patchCapture !== "off" && patchCapture !== "bounded") {
+            throw new Error(`Invalid workspaceState.patchCapture setting: ${String(patchCapture)}`);
+        }
+        const resolvePositive = (value, fallback, name) => {
+            if (value === undefined)
+                return fallback;
+            if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
+                throw new Error(`Invalid workspaceState.${name} setting: ${String(value)}`);
+            }
+            return value;
+        };
+        const maxTotalArtifactBytes = resolvePositive(settings?.maxTotalArtifactBytes, DEFAULT_WORKSPACE_MAX_TOTAL_BYTES, "maxTotalArtifactBytes");
+        const maxPatchBytes = Math.min(resolvePositive(settings?.maxPatchBytes, DEFAULT_WORKSPACE_MAX_PATCH_BYTES, "maxPatchBytes"), maxTotalArtifactBytes);
+        return {
+            patchCapture,
+            maxPatchBytes,
+            maxArtifacts: resolvePositive(settings?.maxArtifacts, DEFAULT_WORKSPACE_MAX_ARTIFACTS, "maxArtifacts"),
+            maxTotalArtifactBytes,
+        };
+    }
     getWebSocketConnectTimeoutMs() {
         return parseTimeoutSetting(this.settings.websocketConnectTimeoutMs, "websocketConnectTimeoutMs");
     }
@@ -788,6 +920,15 @@ export class SettingsManager {
     getThinkingBudgets() {
         return this.settings.thinkingBudgets;
     }
+    getTerminalCapabilityOverrides() {
+        const terminal = this.settings.terminal;
+        const images = terminal?.images;
+        return {
+            ...(images === "kitty" || images === "iterm2" ? { images } : images === false ? { images: null } : {}),
+            ...(typeof terminal?.trueColor === "boolean" ? { trueColor: terminal.trueColor } : {}),
+            ...(typeof terminal?.hyperlinks === "boolean" ? { hyperlinks: terminal.hyperlinks } : {}),
+        };
+    }
     getShowImages() {
         return this.settings.terminal?.showImages ?? true;
     }
@@ -874,6 +1015,14 @@ export class SettingsManager {
         this.markModified("fullscreenScrollbar");
         this.save();
     }
+    getFullscreenCopyOnSelect() {
+        return this.settings.fullscreenCopyOnSelect ?? true;
+    }
+    setFullscreenCopyOnSelect(enabled) {
+        this.globalSettings.fullscreenCopyOnSelect = enabled;
+        this.markModified("fullscreenCopyOnSelect");
+        this.save();
+    }
     getImageAutoResize() {
         return this.settings.images?.autoResize ?? true;
     }