@ikarmic/forge-core 5.0.0 → 5.1.1

package/dist/config-file.js

@@ -1,7 +1,178 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
+import { customProviderProblems } from './custom-providers.js';
+const PERMISSION_ACTIONS = new Set(['allow', 'ask', 'deny']);
+const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const positiveNumber = (n) => typeof n === 'number' && Number.isFinite(n) && n > 0;
+const nonNegativeNumber = (n) => typeof n === 'number' && Number.isFinite(n) && n >= 0;
+const stringList = (v) => (Array.isArray(v) ? v.filter((x) => typeof x === 'string') : undefined);
+const BLOCK_KINDS = {
+    reasoning: ['hidden', 'collapsed', 'expanded'],
+    terminal: ['collapsed', 'expanded'],
+    edit: ['collapsed', 'expanded'],
+    mcp: ['collapsed', 'expanded'],
+};
+/** `display.blocks`: keep the kinds and values the chat understands, warn once about each thing it would silently ignore. */
+function cleanDisplayBlocks(config, filePath, warnings) {
+    const blocks = config.display?.blocks;
+    if (blocks === undefined)
+        return;
+    const display = config.display;
+    if (!isObject(blocks)) {
+        warnings.push(`${filePath}: display.blocks must be an object (reasoning, terminal, edit, mcp); ignored`);
+        delete display.blocks;
+        return;
+    }
+    const kept = {};
+    for (const [kind, value] of Object.entries(blocks)) {
+        const allowed = BLOCK_KINDS[kind];
+        if (!allowed)
+            warnings.push(`${filePath}: display.blocks.${kind} is not a block kind (${Object.keys(BLOCK_KINDS).join(', ')}); ignored`);
+        else if (typeof value !== 'string' || !allowed.includes(value))
+            warnings.push(`${filePath}: display.blocks.${kind} must be ${allowed.join(', ')}; ignored`);
+        else
+            kept[kind] = value;
+    }
+    if (Object.keys(kept).length)
+        display.blocks = kept;
+    else
+        delete display.blocks;
+}
+/** Validate `customProviders`, `modelOverrides`, `modelFilters` and `subagentModel`, dropping what cannot be used with one warning each. */
+function cleanProviderKeys(config, filePath, warnings) {
+    if (config.customProviders !== undefined) {
+        const raw = config.customProviders;
+        if (!isObject(raw)) {
+            warnings.push(`${filePath}: "customProviders" must be an object of provider id → settings; ignored`);
+            delete config.customProviders;
+        }
+        else {
+            const kept = {};
+            const bad = new Set(customProviderProblems(raw).map((p) => p.id));
+            for (const p of customProviderProblems(raw))
+                warnings.push(`${filePath}: ${p.message} Ignored.`);
+            for (const [id, value] of Object.entries(raw)) {
+                if (bad.has(id) || !isObject(value))
+                    continue;
+                const entry = { ...value };
+                if (entry.headers !== undefined && !(isObject(entry.headers) && Object.values(entry.headers).every((h) => typeof h === 'string'))) {
+                    warnings.push(`${filePath}: customProviders.${id}.headers must be text values; headers ignored`);
+                    delete entry.headers;
+                }
+                kept[id] = entry;
+            }
+            if (Object.keys(kept).length)
+                config.customProviders = kept;
+            else
+                delete config.customProviders;
+        }
+    }
+    if (config.modelOverrides !== undefined) {
+        const raw = config.modelOverrides;
+        if (!isObject(raw)) {
+            warnings.push(`${filePath}: "modelOverrides" must be an object of model → numbers; ignored`);
+            delete config.modelOverrides;
+        }
+        else {
+            const kept = {};
+            for (const [model, value] of Object.entries(raw)) {
+                if (!isObject(value)) {
+                    warnings.push(`${filePath}: modelOverrides.${model} must be an object; ignored`);
+                    continue;
+                }
+                const out = {};
+                const limit = isObject(value.limit) ? value.limit : undefined;
+                if (limit) {
+                    const l = {};
+                    for (const k of ['context', 'output']) {
+                        if (limit[k] === undefined)
+                            continue;
+                        if (positiveNumber(limit[k]))
+                            l[k] = limit[k];
+                        else
+                            warnings.push(`${filePath}: modelOverrides.${model}.limit.${k} must be a positive number; ignored`);
+                    }
+                    if (Object.keys(l).length)
+                        out.limit = l;
+                }
+                const cost = isObject(value.cost) ? value.cost : undefined;
+                if (cost) {
+                    const c = {};
+                    for (const k of ['input', 'output']) {
+                        if (cost[k] === undefined)
+                            continue;
+                        if (nonNegativeNumber(cost[k]))
+                            c[k] = cost[k];
+                        else
+                            warnings.push(`${filePath}: modelOverrides.${model}.cost.${k} must be a number of 0 or more; ignored`);
+                    }
+                    if (Object.keys(c).length)
+                        out.cost = c;
+                }
+                if (value.limit !== undefined && !limit)
+                    warnings.push(`${filePath}: modelOverrides.${model}.limit must be an object; ignored`);
+                if (Object.keys(out).length)
+                    kept[model] = out;
+            }
+            if (Object.keys(kept).length)
+                config.modelOverrides = kept;
+            else
+                delete config.modelOverrides;
+        }
+    }
+    if (config.modelFilters !== undefined) {
+        const raw = config.modelFilters;
+        if (!isObject(raw)) {
+            warnings.push(`${filePath}: "modelFilters" must be an object of provider → lists; ignored`);
+            delete config.modelFilters;
+        }
+        else {
+            const kept = {};
+            for (const [provider, value] of Object.entries(raw)) {
+                if (!isObject(value))
+                    continue;
+                const whitelist = stringList(value.whitelist);
+                const blacklist = stringList(value.blacklist);
+                if (whitelist?.length || blacklist?.length)
+                    kept[provider] = { ...(whitelist?.length ? { whitelist } : {}), ...(blacklist?.length ? { blacklist } : {}) };
+            }
+            if (Object.keys(kept).length)
+                config.modelFilters = kept;
+            else
+                delete config.modelFilters;
+        }
+    }
+    if (config.instructions !== undefined) {
+        const list = stringList(config.instructions)?.map((s) => s.trim()).filter(Boolean);
+        if (list?.length)
+            config.instructions = list;
+        else
+            delete config.instructions;
+    }
+    if (config.skillPaths !== undefined) {
+        const list = stringList(config.skillPaths)?.map((s) => s.trim()).filter(Boolean);
+        if (list?.length)
+            config.skillPaths = list;
+        else
+            delete config.skillPaths;
+    }
+    if (config.caCertificates !== undefined) {
+        const list = stringList(config.caCertificates)?.map((s) => s.trim()).filter(Boolean);
+        if (list?.length)
+            config.caCertificates = list;
+        else
+            delete config.caCertificates;
+    }
+    if (config.subagentModel !== undefined) {
+        const v = typeof config.subagentModel === 'string' ? config.subagentModel.trim() : '';
+        if (v)
+            config.subagentModel = v;
+        else
+            delete config.subagentModel;
+    }
+}
 /** Returns `~/.forge/config.json` for the current user. */
 export function defaultForgeConfigPath() {
     return path.join(homedir(), '.forge', 'config.json');
@@ -40,6 +211,41 @@ export async function loadForgeConfigFile(configPath) {
                 }
             }
         }
+        if (config.permission !== undefined) {
+            const raw = config.permission;
+            if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+                warnings.push(`${filePath}: "permission" must be an object of permission → action or pattern map; ignored`);
+                delete config.permission;
+            }
+            else {
+                const kept = {};
+                for (const [perm, value] of Object.entries(raw)) {
+                    if (typeof value === 'string') {
+                        if (PERMISSION_ACTIONS.has(value))
+                            kept[perm] = value;
+                        else
+                            warnings.push(`${filePath}: permission.${perm} is "${value}", not allow, ask or deny; ignored`);
+                    }
+                    else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                        const patterns = {};
+                        for (const [pattern, action] of Object.entries(value)) {
+                            if (typeof action === 'string' && PERMISSION_ACTIONS.has(action))
+                                patterns[pattern] = action;
+                            else
+                                warnings.push(`${filePath}: permission.${perm}["${pattern}"] is "${String(action)}", not allow, ask or deny; ignored`);
+                        }
+                        if (Object.keys(patterns).length)
+                            kept[perm] = patterns;
+                    }
+                    else {
+                        warnings.push(`${filePath}: permission.${perm} must be allow, ask, deny or a pattern map; ignored`);
+                    }
+                }
+                config.permission = kept;
+            }
+        }
+        cleanProviderKeys(config, filePath, warnings);
+        cleanDisplayBlocks(config, filePath, warnings);
         return { config, warnings };
     }
     catch (err) {
@@ -52,8 +258,46 @@ export async function loadForgeConfigFile(configPath) {
  */
 export async function saveForgeConfigFile(partial, configPath) {
     const filePath = configPath ?? defaultForgeConfigPath();
-    const { config: existing } = await loadForgeConfigFile(filePath);
-    const merged = { ...existing, ...partial };
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
+    await updateJsonFile(filePath, (existing) => ({ ...existing, ...partial }));
+}
+const fileQueues = new Map();
+/**
+ * Read-modify-write of a JSON settings file, safely:
+ * - merged over the file as written, not the cleaned config, so keys this version drops or does not know survive;
+ * - a file that exists but is not valid JSON is never overwritten (that would replace every setting with one);
+ * - writes to one path from this process run one after another, so two saves at once both land;
+ * - written to a temporary file and renamed, so a crash cannot leave half a file.
+ */
+export function updateJsonFile(filePath, update) {
+    const key = path.resolve(filePath);
+    const run = async () => {
+        let existing = {};
+        let text;
+        try {
+            text = await readFile(filePath, 'utf8');
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT')
+                throw err;
+        }
+        if (text !== undefined && text.trim()) {
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch (err) {
+                throw new Error(`${filePath} is not valid JSON (${err.message}); fix it before saving, so your other settings are not lost`);
+            }
+            if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw new Error(`${filePath} must hold a JSON object; not saving over it`);
+            existing = parsed;
+        }
+        await mkdir(path.dirname(filePath), { recursive: true });
+        const tmp = `${filePath}.${process.pid}.tmp`;
+        await writeFile(tmp, JSON.stringify(update(existing), null, 2) + '\n', 'utf8');
+        await rename(tmp, filePath);
+    };
+    const next = (fileQueues.get(key) ?? Promise.resolve()).then(run, run);
+    fileQueues.set(key, next.catch(() => undefined));
+    return next;
 }

package/dist/config-merge.d.ts

@@ -0,0 +1,13 @@
+import { type ForgeConfigFile, type LoadForgeConfigFileResult } from './config-file.js';
+/**
+ * The shared config as one object: `~/.forge/config.json`, then the workspace's `.forge/config.json` on top.
+ * A project file can pick the model and add stricter rules, but it can never loosen what the user decided:
+ * its `allow` permission rules are dropped, and the keys that hold approvals or delete data are only read
+ * from the user file. An untrusted workspace contributes nothing.
+ */
+export declare function projectConfigPath(cwd: string): string;
+export declare const USER_ONLY_CONFIG_KEYS: ReadonlyArray<keyof ForgeConfigFile>;
+export declare function loadMergedForgeConfig(cwd: string, opts: {
+    trusted: boolean;
+    userPath?: string;
+}): Promise<LoadForgeConfigFileResult>;

package/dist/config-merge.js

@@ -0,0 +1,67 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { loadForgeConfigFile } from './config-file.js';
+/**
+ * The shared config as one object: `~/.forge/config.json`, then the workspace's `.forge/config.json` on top.
+ * A project file can pick the model and add stricter rules, but it can never loosen what the user decided:
+ * its `allow` permission rules are dropped, and the keys that hold approvals or delete data are only read
+ * from the user file. An untrusted workspace contributes nothing.
+ */
+export function projectConfigPath(cwd) {
+    return path.join(cwd, '.forge', 'config.json');
+}
+// customProviders is user-only because an entry names a URL and the environment variable whose value is sent there:
+// a repository must not be able to point a key at a host of its choosing.
+export const USER_ONLY_CONFIG_KEYS = ['autoApproveTools', 'autoApproveCommands', 'sessionRetentionDays', 'customProviders', 'instructions', 'skillPaths', 'caCertificates'];
+export async function loadMergedForgeConfig(cwd, opts) {
+    const user = await loadForgeConfigFile(opts.userPath);
+    const file = projectConfigPath(cwd);
+    if (!opts.trusted || !existsSync(file))
+        return user;
+    const project = await loadForgeConfigFile(file);
+    const warnings = [...user.warnings, ...project.warnings];
+    const p = project.config;
+    const merged = { ...user.config };
+    for (const key of USER_ONLY_CONFIG_KEYS) {
+        if (p[key] !== undefined)
+            warnings.push(`${file}: "${key}" is only read from the user config (~/.forge/config.json); ignored`);
+    }
+    for (const key of ['provider', 'model', 'completionModel', 'compactionModel', 'reasoningEffort', 'subagentModel']) {
+        if (p[key] !== undefined)
+            merged[key] = p[key];
+    }
+    if (p.modelOverrides)
+        merged.modelOverrides = { ...user.config.modelOverrides, ...p.modelOverrides };
+    if (p.aliases)
+        merged.aliases = { ...user.config.aliases, ...p.aliases };
+    if (p.modeModels)
+        merged.modeModels = { ...user.config.modeModels, ...p.modeModels };
+    if (p.display)
+        merged.display = { ...user.config.display, ...p.display };
+    if (p.disabledProviders)
+        merged.disabledProviders = [...new Set([...(user.config.disabledProviders ?? []), ...p.disabledProviders])];
+    if (p.permission) {
+        const permission = tighten(user.config.permission, p.permission);
+        if (permission)
+            merged.permission = permission;
+    }
+    return { config: merged, warnings };
+}
+/** User rules first, then the project's `ask` and `deny` rules (an `allow` is dropped), each after everything of the user's. */
+function tighten(user, project) {
+    const out = { ...(user ?? {}) };
+    for (const [permission, value] of Object.entries(project)) {
+        const rules = typeof value === 'string' ? [['*', value]] : Object.entries(value);
+        const kept = rules.filter(([, action]) => action !== 'allow');
+        if (kept.length === 0)
+            continue;
+        const existing = out[permission];
+        const target = typeof existing === 'string' ? { '*': existing } : { ...(existing ?? {}) };
+        for (const [pattern, action] of kept) {
+            delete target[pattern];
+            target[pattern] = action;
+        }
+        out[permission] = target;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}