agentsw 0.7.1 → 0.7.2

package/dist/targets/opencode.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import { appDataDir, backupFile, expandHome, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
+import { isJsonObject } from "../jsonc.js";
+import { transactionalTarget } from "../target-transaction.js";
 const customDir = process.env.OPENCODE_CONFIG_DIR?.trim();
 const configFile = customDir
     ? path.join(expandHome(customDir), "opencode.json")
@@ -9,7 +11,7 @@ const configFile = customDir
  * opencode: custom providers in ~/.config/opencode/opencode.json "provider" map,
  * backed by @ai-sdk/openai-compatible or @ai-sdk/anthropic npm loaders.
  */
-export const opencode = {
+export const opencode = transactionalTarget({
     id: "opencode",
     name: "opencode",
     protocols: ["openai", "anthropic"],
@@ -17,20 +19,32 @@ export const opencode = {
     detect: () => fs.existsSync(path.dirname(configFile)),
     async apply(provider) {
         const notes = [];
-        const config = readJsonIfExists(configFile) ?? {
-            $schema: "https://opencode.ai/config.json",
-        };
+        const configValue = readJsonIfExists(configFile);
+        const config = configValue === undefined ? { $schema: "https://opencode.ai/config.json" } : configValue;
+        if (!isJsonObject(config) || (config.provider !== undefined && !isJsonObject(config.provider))) {
+            throw new Error(`${configFile}: expected config and provider to be JSON objects`);
+        }
         const anthropic = provider.protocol === "anthropic";
         const providerMap = { ...config.provider };
         // Keys agentsw does not model (custom options, per-model extras) are the user's,
         // but a key it owns and no longer emits is cleared rather than inherited from last sync.
         const existing = providerMap[provider.id];
+        if (existing !== undefined && !isJsonObject(existing)) {
+            throw new Error(`${configFile}: expected the selected provider to be a JSON object`);
+        }
         const prev = (existing && typeof existing === "object" && !Array.isArray(existing)
             ? existing
             : {});
+        if ((prev.models !== undefined && !isJsonObject(prev.models)) ||
+            (prev.options !== undefined && !isJsonObject(prev.options))) {
+            throw new Error(`${configFile}: expected provider models and options to be JSON objects`);
+        }
         const prevModels = (prev.models ?? {});
         const models = {};
         for (const m of provider.models) {
+            if (prevModels[m.id] !== undefined && !isJsonObject(prevModels[m.id])) {
+                throw new Error(`${configFile}: expected each model to be a JSON object`);
+            }
             const old = { ...prevModels[m.id] };
             for (const key of ["name", "reasoning", "attachment", "cost", "limit"])
                 delete old[key];
@@ -61,7 +75,9 @@ export const opencode = {
         }
         providerMap[provider.id] = {
             ...prev,
-            npm: anthropic ? "@ai-sdk/anthropic" : provider.openaiApi === "responses" ? "@ai-sdk/openai" : "@ai-sdk/openai-compatible",
+            npm: anthropic ? "@ai-sdk/anthropic" :
+                (provider.openaiApi ?? (prev.npm === "@ai-sdk/openai" ? "responses" : "completions")) === "responses"
+                    ? "@ai-sdk/openai" : "@ai-sdk/openai-compatible",
             name: provider.name,
             options: {
                 ...prev.options,
@@ -82,6 +98,9 @@ export const opencode = {
     },
     async prune(provider) {
         const config = readJsonIfExists(configFile);
+        if (config !== undefined && (!isJsonObject(config) || (config.provider !== undefined && !isJsonObject(config.provider)))) {
+            throw new Error(`${configFile}: expected config and provider to be JSON objects`);
+        }
         const providerMap = config?.provider;
         if (!config || !providerMap?.[provider.id]) {
             return { app: this.id, changed: [], notes: [], skipped: `no provider.${provider.id} entry` };
@@ -129,6 +148,8 @@ export const opencode = {
                 keyEnv = ref[1];
                 apiKey = process.env[ref[1]];
             }
+            if (apiKey?.startsWith("{file:"))
+                apiKey = undefined;
             const models = Object.keys(entry.models ?? {});
             const defaultModel = activeProvider === id ? activeModel : undefined;
             if (defaultModel && !models.includes(defaultModel))
@@ -136,4 +157,4 @@ export const opencode = {
             return [{ id, name: entry.name ?? id, protocol, openaiApi, baseUrl, apiKey, keyEnv, models, defaultModel, source: self }];
         });
     },
-};
+});

package/dist/targets/pistyle.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { backupFile, home, writeFileAtomic } from "../fsutil.js";
 import { editJsoncObject, isJsonObject, readJsoncObject } from "../jsonc.js";
 import { looksLikeEnvName } from "../slug.js";
+import { transactionalTarget } from "../target-transaction.js";
 import { apiValue, classifyApi, entryApi, mergeModels, sdkBaseUrl, stripConflictingOverrides } from "./wire.js";
 /** Per-model keys this adapter writes; one that stops being emitted is cleared, not inherited. */
 const OWNED_MODEL_KEYS = [
@@ -62,7 +63,7 @@ export function piStyleTarget(opts) {
             return env.startsWith("~") ? path.join(home, env.slice(1)) : env;
         return path.join(home, opts.configDirName);
     };
-    return {
+    return transactionalTarget({
         id: opts.id,
         name: opts.name,
         protocols: ["openai", "anthropic"],
@@ -81,7 +82,7 @@ export function piStyleTarget(opts) {
             // Keys agentsw does not model (headers, authHeader, oauth, ...) and per-model extras
             // are the user's; a re-sync overwrites only the fields it owns.
             const prev = providers[provider.id] ?? {};
-            const api = apiValue(provider.protocol, provider.openaiApi, entryApi(prev));
+            const api = apiValue(provider.protocol, provider.openaiApi, prev.api ?? entryApi(prev));
             const baseUrl = sdkBaseUrl(provider.protocol, provider.baseUrl);
             const models = mergeModels(prev.models, provider.models.map((m) => ({
                 id: m.id,
@@ -193,16 +194,19 @@ export function piStyleTarget(opts) {
                 let keyEnv;
                 const raw = typeof entry.apiKey === "string" && entry.apiKey ? entry.apiKey : undefined;
                 if (raw) {
-                    if (raw.startsWith("$") && raw.length > 1) {
-                        keyEnv = raw.slice(1);
-                        apiKey = process.env[keyEnv];
+                    const envRef = raw.match(/^\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))$/)
+                        ?? raw.match(/^\{env:([A-Za-z_][A-Za-z0-9_]*)\}$/)
+                        ?? raw.match(/^env:([A-Za-z_][A-Za-z0-9_]*)$/);
+                    if (envRef) {
+                        keyEnv = envRef[1] ?? envRef[2];
+                        apiKey = keyEnv ? process.env[keyEnv] : undefined;
                     }
                     else if (opts.id === "prime" && looksLikeEnvName(raw)) {
-                        // prime resolves bare env names; falls back to the literal string
                         keyEnv = raw;
                         apiKey = process.env[raw] ?? raw;
                     }
-                    else {
+                    else if (!/^(?:!|\$|\{(?:file|env):|file:|env:|~\/|\/)/.test(raw)) {
+                        // Commands and file references are never executed or exported as literal credentials.
                         apiKey = raw;
                     }
                 }
@@ -226,7 +230,7 @@ export function piStyleTarget(opts) {
                 ];
             });
         },
-    };
+    });
 }
 export const pi = piStyleTarget({
     id: "pi",

package/dist/targets/wire.js

@@ -18,7 +18,7 @@ export function classifyApi(api) {
         return { protocol: "anthropic" };
     if (api === "openai-completions")
         return { protocol: "openai", openaiApi: "completions" };
-    if (RESPONSES_APIS[api])
+    if (RESPONSES_APIS[api] === true)
         return { protocol: "openai", openaiApi: "responses" };
     return undefined;
 }
@@ -44,19 +44,25 @@ export function apiValue(protocol, openaiApi, existing) {
  * provider cannot represent it — so importers skip it rather than guess.
  */
 export function entryApi(entry) {
-    if (typeof entry.api === "string")
+    if (!Array.isArray(entry.models) || entry.models.length === 0)
         return entry.api;
-    if (!Array.isArray(entry.models))
-        return undefined;
     let single;
+    let singleWire;
     for (const model of entry.models) {
-        const api = model?.api;
-        if (typeof api !== "string")
-            continue;
-        if (single === undefined)
+        // A provider default applies only to models without their own override.
+        if (!model || typeof model !== "object" || Array.isArray(model))
+            return undefined;
+        const api = model.api === undefined ? entry.api : model.api;
+        const wire = classifyApi(api);
+        if (!wire)
+            return undefined;
+        if (single === undefined) {
             single = api;
-        else if (single !== api)
+            singleWire = wire;
+        }
+        else if (singleWire?.protocol !== wire.protocol || singleWire?.openaiApi !== wire.openaiApi) {
             return undefined;
+        }
     }
     return single;
 }

package/dist/targets/workbuddy.js

@@ -1,35 +1,76 @@
 import fs from "node:fs";
 import path from "node:path";
 import { appDataDir, backupFile, home, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
+import { isJsonObject } from "../jsonc.js";
+import { localProviderId } from "../provider-identity.js";
 import { providerIdFromBaseUrl, providerNameFromBaseUrl } from "../slug.js";
+import { transactionalTarget } from "../target-transaction.js";
 function configDir() {
-    return process.env.WORKBUDDY_CONFIG_DIR?.trim() ?? process.env.CODEBUDDY_CONFIG_DIR?.trim() ??
+    return process.env.WORKBUDDY_CONFIG_DIR?.trim() || process.env.CODEBUDDY_CONFIG_DIR?.trim() ||
         (process.platform === "win32" ? appDataDir("workbuddy") : path.join(home, ".workbuddy"));
 }
-/**
- * models.json accepts a raw array (desktop writes) or {models, availableModels} (CLI writes).
- * Runtime-narrow both shapes; entries without a string id are dropped (WorkBuddy skips them too).
- */
+function isModel(row) {
+    return isJsonObject(row) && typeof row.id === "string";
+}
+/** Preserve unknown rows and container fields even though WorkBuddy skips those rows. */
 function readWorkbuddyModels(file) {
     const raw = readJsonIfExists(file);
-    const rows = Array.isArray(raw)
-        ? raw
-        : raw && typeof raw === "object" && "models" in raw && Array.isArray(raw.models)
-            ? raw.models
-            : [];
-    const models = rows.filter((m) => !!m && typeof m === "object" && "id" in m && typeof m.id === "string");
-    const availableModels = !Array.isArray(raw) && raw && typeof raw === "object" && "availableModels" in raw && Array.isArray(raw.availableModels)
-        ? raw.availableModels.filter((id) => typeof id === "string")
-        : [];
-    return { models, availableModels, existed: raw !== undefined };
+    if (raw !== undefined && !Array.isArray(raw) && !isJsonObject(raw)) {
+        throw new Error(`${file}: expected a model array or JSON object`);
+    }
+    const container = isJsonObject(raw) ? raw : {};
+    if (container.models !== undefined && !Array.isArray(container.models)) {
+        throw new Error(`${file}: expected models to be an array`);
+    }
+    if (container.availableModels !== undefined &&
+        (!Array.isArray(container.availableModels) || container.availableModels.some((id) => typeof id !== "string"))) {
+        throw new Error(`${file}: expected availableModels to be an array of strings`);
+    }
+    const rows = Array.isArray(raw) ? raw : container.models ?? [];
+    const availableModels = container.availableModels ?? [];
+    return { rows, models: rows.filter(isModel), container, availableModels, existed: raw !== undefined };
+}
+/** Root endpoints retain WorkBuddy's /v1 convention; custom base paths never gain /v1. */
+function completionsUrl(baseUrl) {
+    const url = new URL(baseUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:")
+        throw new Error("WorkBuddy requires an HTTP(S) endpoint");
+    const pathname = url.pathname.replace(/\/+$/, "");
+    url.pathname = pathname.endsWith("/chat/completions") ? pathname : `${pathname || "/v1"}/chat/completions`;
+    return url.toString();
+}
+function ownsModel(row, provider, endpoint) {
+    if (row.agentswProviderId !== undefined)
+        return row.agentswProviderId === provider.id;
+    if (typeof row.url !== "string" || row.apiKey !== provider.apiKey)
+        return false;
+    try {
+        return completionsUrl(row.url) === endpoint;
+    }
+    catch {
+        return false;
+    }
+}
+const OWNED_MODEL_KEYS = [
+    "id", "name", "vendor", "url", "apiKey", "agentswProviderId", "maxInputTokens", "maxOutputTokens",
+    "supportsToolCall", "supportsImages", "supportsReasoning",
+];
+/** Import and management must identify the same endpoint without rewriting query values. */
+export function workbuddyBaseUrl(raw) {
+    try {
+        const url = new URL(raw);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            return undefined;
+        const pathname = url.pathname.replace(/\/+$/, "");
+        url.pathname = pathname === "/chat/completions" ? pathname : pathname.replace(/\/chat\/completions$/, "");
+        return url.toString();
+    }
+    catch {
+        return undefined;
+    }
 }
-/**
- * WorkBuddy (Tencent CodeBuddy family): custom models live in ~/.workbuddy/models.json.
- * Each entry carries its own full OpenAI chat-completions `url` + `apiKey`; entries merge
- * into the model selector ("custom" section). Default model via settings.json "model".
- * Custom entries speak the OpenAI wire only — anthropic-protocol providers are skipped.
- */
-export const workbuddy = {
+/** WorkBuddy stores per-model full chat-completions URLs and credentials. */
+export const workbuddy = transactionalTarget({
     id: "workbuddy",
     name: "WorkBuddy",
     protocols: ["openai"],
@@ -40,31 +81,51 @@ export const workbuddy = {
         const modelsFile = path.join(dir, "models.json");
         const settingsFile = path.join(dir, "settings.json");
         const notes = [];
-        const base = provider.baseUrl.replace(/\/+$/, "");
-        const url = /\/v\d+$/.test(base) ? `${base}/chat/completions` : `${base}/v1/chat/completions`;
-        // models.json accepts a raw array (desktop) or {models, availableModels} (CLI); write the object shape.
-        const { models: existingModels, availableModels: existingAvailable } = readWorkbuddyModels(modelsFile);
-        const ourIds = provider.models.map((m) => m.id);
-        const kept = existingModels.filter((m) => !ourIds.includes(m.id));
-        const ours = provider.models.map((m) => ({
-            id: m.id,
-            name: m.name ?? m.id,
-            vendor: provider.name,
-            url,
-            apiKey: provider.apiKey,
-            ...(m.maxInput ?? m.contextWindow ? { maxInputTokens: m.maxInput ?? m.contextWindow } : {}),
-            ...(m.maxOutput ? { maxOutputTokens: m.maxOutput } : {}),
-            supportsToolCall: true,
-            ...(m.imageInput !== undefined ? { supportsImages: !!m.imageInput } : {}),
-            ...(m.reasoning !== undefined ? { supportsReasoning: !!m.reasoning } : {}),
-        }));
-        const availableModels = [...new Set([...existingAvailable, ...ourIds])];
+        const url = completionsUrl(provider.baseUrl);
+        const { rows, models, container, availableModels: existingAvailable } = readWorkbuddyModels(modelsFile);
+        const settingsValue = readJsonIfExists(settingsFile);
+        const settings = settingsValue === undefined ? {} : settingsValue;
+        if (!isJsonObject(settings))
+            throw new Error(`${settingsFile}: expected a JSON object`);
+        const owned = models.filter((row) => ownsModel(row, provider, url));
+        const ownedRows = new Set(owned);
+        const ourIds = new Set(provider.models.map((model) => model.id));
+        const kept = rows.filter((row) => !isModel(row) || !ownedRows.has(row));
+        for (const row of kept) {
+            if (isModel(row) && ourIds.has(row.id)) {
+                throw new Error(`${modelsFile}: model ${row.id} belongs to another account; refusing to overwrite it`);
+            }
+        }
+        const previous = new Map(owned.map((row) => [row.id, row]));
+        const ours = provider.models.map((model) => {
+            const custom = { ...previous.get(model.id) };
+            for (const key of OWNED_MODEL_KEYS)
+                delete custom[key];
+            return {
+                ...custom,
+                id: model.id,
+                name: model.name ?? model.id,
+                vendor: provider.name,
+                url,
+                apiKey: provider.apiKey,
+                agentswProviderId: provider.id,
+                ...(model.maxInput ?? model.contextWindow ? { maxInputTokens: model.maxInput ?? model.contextWindow } : {}),
+                ...(model.maxOutput ? { maxOutputTokens: model.maxOutput } : {}),
+                supportsToolCall: true,
+                ...(model.imageInput !== undefined ? { supportsImages: !!model.imageInput } : {}),
+                ...(model.reasoning !== undefined ? { supportsReasoning: !!model.reasoning } : {}),
+            };
+        });
+        const removedIds = new Set(owned.map((row) => row.id));
+        const keptIds = new Set(kept.filter(isModel).map((row) => row.id));
+        const availableModels = [...new Set([
+                ...existingAvailable.filter((id) => !removedIds.has(id) || keptIds.has(id)), ...ourIds,
+            ])];
+        settings.model = provider.defaultModel;
         const modelsBackup = backupFile(modelsFile);
         if (modelsBackup)
             notes.push(`backup: ${modelsBackup}`);
-        writeFileAtomic(modelsFile, JSON.stringify({ models: [...kept, ...ours], availableModels }, null, 2) + "\n");
-        const settings = readJsonIfExists(settingsFile) ?? {};
-        settings.model = provider.defaultModel;
+        writeFileAtomic(modelsFile, JSON.stringify({ ...container, models: [...kept, ...ours], availableModels }, null, 2) + "\n", 0o600);
         const settingsBackup = backupFile(settingsFile);
         if (settingsBackup)
             notes.push(`backup: ${settingsBackup}`);
@@ -76,24 +137,30 @@ export const workbuddy = {
         const dir = configDir();
         const modelsFile = path.join(dir, "models.json");
         const settingsFile = path.join(dir, "settings.json");
-        const { models, availableModels: available, existed } = readWorkbuddyModels(modelsFile);
+        const { rows, models, container, availableModels: available, existed } = readWorkbuddyModels(modelsFile);
         if (!existed)
             return { app: this.id, changed: [], notes: [], skipped: "no models.json" };
-        const ourIds = provider.models.map((m) => m.id);
-        // ours = matching id AND vendor (id alone could collide with entries from another provider)
-        const kept = models.filter((m) => !(ourIds.includes(m.id) && m.vendor === provider.name));
-        if (kept.length === models.length) {
+        const endpoint = completionsUrl(provider.baseUrl);
+        const owned = new Set(models.filter((row) => ownsModel(row, provider, endpoint)));
+        if (!owned.size)
             return { app: this.id, changed: [], notes: [], skipped: "no entries from this provider" };
-        }
-        const keptIds = kept.map((m) => m.id);
+        const kept = rows.filter((row) => !isModel(row) || !owned.has(row));
+        const keptIds = new Set(kept.filter(isModel).map((row) => row.id));
+        const removedIds = new Set([...owned].map((row) => row.id));
+        const settings = readJsonIfExists(settingsFile);
+        if (settings !== undefined && !isJsonObject(settings))
+            throw new Error(`${settingsFile}: expected a JSON object`);
         const notes = [];
         const modelsBackup = backupFile(modelsFile);
         if (modelsBackup)
             notes.push(`backup: ${modelsBackup}`);
-        writeFileAtomic(modelsFile, JSON.stringify({ models: kept, availableModels: available.filter((id) => keptIds.includes(id)) }, null, 2) + "\n");
+        writeFileAtomic(modelsFile, JSON.stringify({
+            ...container,
+            models: kept,
+            availableModels: available.filter((id) => !removedIds.has(id) || keptIds.has(id)),
+        }, null, 2) + "\n", 0o600);
         const changed = [modelsFile];
-        const settings = readJsonIfExists(settingsFile);
-        if (settings && typeof settings.model === "string" && ourIds.includes(settings.model)) {
+        if (settings && typeof settings.model === "string" && removedIds.has(settings.model) && !keptIds.has(settings.model)) {
             delete settings.model;
             const settingsBackup = backupFile(settingsFile);
             if (settingsBackup)
@@ -109,37 +176,45 @@ export const workbuddy = {
         return settings?.model;
     },
     candidates() {
-        // Each model has its own endpoint and credential; different accounts must stay separate.
         const { models } = readWorkbuddyModels(path.join(configDir(), "models.json"));
         if (models.length === 0)
             return [];
         const settings = readJsonIfExists(path.join(configDir(), "settings.json"));
         const groups = new Map();
-        for (const m of models) {
-            const row = m;
+        for (const row of models) {
             if (typeof row.url !== "string" || !row.url)
                 continue;
-            const baseUrl = row.url.replace(/\/+$/, "").replace(/\/chat\/completions$/, "");
-            if (!/^https?:\/\//.test(baseUrl))
+            const baseUrl = workbuddyBaseUrl(row.url);
+            if (!baseUrl)
                 continue;
-            const apiKey = typeof row.apiKey === "string" && row.apiKey ? row.apiKey : undefined;
+            const apiKey = typeof row.apiKey === "string" ? row.apiKey : undefined;
             const key = JSON.stringify([baseUrl, apiKey ?? null]);
-            let g = groups.get(key);
-            if (!g) {
-                g = { baseUrl, apiKey, ids: [] };
-                groups.set(key, g);
+            let group = groups.get(key);
+            if (!group) {
+                const id = providerIdFromBaseUrl(baseUrl, "openai");
+                const candidate = {
+                    id,
+                    generatedId: true,
+                    name: providerNameFromBaseUrl(baseUrl, "openai"),
+                    protocol: "openai",
+                    baseUrl,
+                    apiKey,
+                    models: [],
+                    source: this.id,
+                };
+                candidate.localId = localProviderId(candidate);
+                group = { candidate };
+                groups.set(key, group);
+            }
+            if (!group.vendor && typeof row.vendor === "string" && row.vendor) {
+                group.vendor = row.vendor;
+                group.candidate.name = row.vendor;
             }
-            if (!g.ids.includes(m.id))
-                g.ids.push(m.id);
-            if (!g.vendor && typeof row.vendor === "string")
-                g.vendor = row.vendor;
+            if (!group.candidate.models.includes(row.id))
+                group.candidate.models.push(row.id);
+            if (settings?.model === row.id)
+                group.candidate.defaultModel = row.id;
         }
-        const self = this.id;
-        return [...groups.values()].map((g) => {
-            const { baseUrl } = g;
-            const id = providerIdFromBaseUrl(baseUrl, "openai");
-            const defaultModel = settings?.model && g.ids.includes(settings.model) ? settings.model : undefined;
-            return { id, generatedId: true, name: g.vendor ?? providerNameFromBaseUrl(baseUrl, "openai"), protocol: "openai", baseUrl, apiKey: g.apiKey, models: g.ids, defaultModel, source: self };
-        });
+        return [...groups.values()].map((group) => group.candidate);
     },
-};
+});

package/dist/yaml.js

@@ -0,0 +1,39 @@
+import YAML from "yaml";
+/** Resolve aliases in document context before edits can mutate or remove anchors. */
+export function parseYamlMapping(file, text) {
+    try {
+        const doc = text ? YAML.parseDocument(text) : new YAML.Document({});
+        if (doc.errors.length)
+            throw new Error("parse error");
+        if (doc.contents == null)
+            doc.contents = doc.createNode({});
+        // YAML permits cycles; application configuration does not. The document
+        // conversion also enforces YAML's alias expansion limit before we detach.
+        JSON.stringify(doc.toJS());
+        const expanded = new Map();
+        YAML.visit(doc, {
+            Alias(_key, alias) {
+                const node = doc.createNode(alias.toJS(doc), { aliasDuplicateObjects: false });
+                node.comment = alias.comment;
+                node.commentBefore = alias.commentBefore;
+                node.spaceBefore = alias.spaceBefore;
+                expanded.set(alias, node);
+            },
+        });
+        // Resolve every alias before replacing any, since anchors may be reused.
+        YAML.visit(doc, { Alias: (_key, alias) => expanded.get(alias) });
+        if (!YAML.isMap(doc.contents))
+            throw new Error("expected a configuration mapping");
+        return doc;
+    }
+    catch {
+        // Parser messages include source lines, which may contain credentials.
+        throw new Error(`${file}: invalid YAML configuration (expected an acyclic mapping with valid aliases)`);
+    }
+}
+/** Validate the emitted configuration before any backup or write. */
+export function serializeYamlMapping(file, doc) {
+    const text = doc.toString();
+    parseYamlMapping(file, text);
+    return text;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsw",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "CLI provider switcher for coding agents: manage OpenAI/Anthropic-protocol providers in one place and sync them, with models.dev metadata, into Claude Code, Codex, omp, pi, prime-agent, opencode, Hermes, WorkBuddy and DeepSeek Harness",
   "type": "module",
   "repository": {
@@ -30,7 +30,7 @@
     "dist"
   ],
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=22.13.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -44,12 +44,14 @@
     "jsonc-parser": "^3.3.1",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2",
+    "semver": "^7.8.5",
     "smol-toml": "^1.8.0",
     "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@types/node": "^26.4.0",
     "@types/prompts": "^2.4.9",
+    "@types/semver": "^7.8.0",
     "tsx": "^4.23.12",
     "typescript": "^7.0.2"
   }