agentsw 0.6.1 → 0.6.2

package/dist/jsonc.js

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import { applyEdits, createScanner, getNodeValue, modify, parseTree, printParseErrorCode, } from "jsonc-parser";
+export function isJsonObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseJsoncObject(file, text) {
+    const source = text.startsWith("\uFEFF") ? text.slice(1) : text;
+    const errors = [];
+    const root = parseTree(source, errors, { allowTrailingComma: true });
+    const error = errors[0];
+    if (error) {
+        // Do not quote source text: config files can contain credentials.
+        throw new Error(`${file}: invalid JSONC (${printParseErrorCode(error.error)} at offset ${error.offset})`);
+    }
+    if (root?.type !== "object")
+        throw new Error(`${file}: expected a JSON object at the document root`);
+    // Parsing resolves duplicate keys last-wins, but modify edits the first occurrence.
+    // Reject that ambiguity at any depth rather than syncing a value the agent will not read.
+    const checkDuplicates = (node) => {
+        const names = node.type === "object" ? new Set() : undefined;
+        for (const child of node.children ?? []) {
+            if (names) {
+                const name = child.children[0].value;
+                if (names.has(name)) {
+                    throw new Error(`${file}: invalid JSONC (duplicate object property at offset ${child.offset})`);
+                }
+                names.add(name);
+            }
+            checkDuplicates(child);
+        }
+    };
+    checkDuplicates(root);
+    return getNodeValue(root);
+}
+/** Only missing files initialize to an empty object; unreadable or invalid files must not be replaced. */
+export function readJsoncObject(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { file, text: "{}\n", value: {} };
+        throw error;
+    }
+    return { file, text, value: parseJsoncObject(file, text) };
+}
+function comments(text) {
+    const result = [];
+    const scanner = createScanner(text);
+    for (let token = scanner.scan(); token !== 17 /* SyntaxKind.EOF */; token = scanner.scan()) {
+        if (token === 12 /* SyntaxKind.LineCommentTrivia */ || token === 13 /* SyntaxKind.BlockCommentTrivia */) {
+            result.push(text.slice(scanner.getTokenOffset(), scanner.getTokenOffset() + scanner.getTokenLength()));
+        }
+    }
+    return result;
+}
+/** modify() may include adjacent comments in deletion ranges; retain them as detached comments. */
+function retainComments(text, edit, eol) {
+    const remaining = new Map();
+    for (const comment of comments(edit.content))
+        remaining.set(comment, (remaining.get(comment) ?? 0) + 1);
+    const removed = [];
+    for (const comment of comments(text.slice(edit.offset, edit.offset + edit.length))) {
+        const count = remaining.get(comment) ?? 0;
+        if (count)
+            remaining.set(comment, count - 1);
+        else
+            removed.push(comment);
+    }
+    return removed.length ? { ...edit, content: eol + removed.join(eol) + eol + edit.content } : edit;
+}
+/** Change only differing values, leaving unrelated fields, comments, and string literals intact. */
+export function editJsoncObject(document, value) {
+    const bom = document.text.startsWith("\uFEFF") ? "\uFEFF" : "";
+    let text = bom ? document.text.slice(1) : document.text;
+    const eol = text.includes("\r\n") ? "\r\n" : "\n";
+    const update = (location, previous, next) => {
+        if (previous === next)
+            return;
+        if (isJsonObject(previous) && isJsonObject(next)) {
+            const keys = Object.keys(next);
+            if (keys.length || !Object.keys(previous).length) {
+                // Add before deleting, so a trailing-comma object never temporarily loses its last property.
+                for (const key of keys)
+                    update([...location, key], previous[key], next[key]);
+                for (const key of Object.keys(previous)) {
+                    if (!Object.hasOwn(next, key))
+                        update([...location, key], previous[key], undefined);
+                }
+                return;
+            }
+            // Replacing an emptying object also removes its trailing comma (modify's last-property
+            // deletion otherwise leaves `{,}`). retainComments keeps comments from the removed subtree.
+        }
+        // Replace shrinking arrays whole: modify's last-element deletion can truncate a compact
+        // value incorrectly. Equal-length/growing arrays still get incremental, comment-safe edits.
+        if (Array.isArray(previous) && Array.isArray(next) && next.length >= previous.length) {
+            for (let index = 0; index < next.length; index++) {
+                update([...location, index], previous[index], next[index]);
+            }
+            return;
+        }
+        const edits = modify(text, location, next, { formattingOptions: { insertSpaces: true, tabSize: 2, eol } });
+        text = applyEdits(text, edits.map((edit) => retainComments(text, edit, eol)));
+    };
+    update([], document.value, value);
+    // Never let a library edit boundary or comment relocation write malformed output.
+    parseJsoncObject(document.file, text);
+    return bom + text;
+}

package/dist/targets/omp.js

@@ -9,6 +9,51 @@ const OWNED_MODEL_KEYS = ["id", "name", "reasoning", "input", "contextWindow", "
 const agentDir = path.join(home, ".omp", "agent");
 const modelsYml = path.join(agentDir, "models.yml");
 const modelsYaml = path.join(agentDir, "models.yaml");
+/** Resolve references before edits can remove their anchors or mutate shared providers. */
+function parseModelsDocument(file, text) {
+    try {
+        const doc = text ? YAML.parseDocument(text) : new YAML.Document({});
+        if (doc.errors.length)
+            throw doc.errors[0];
+        if (doc.contents == null)
+            doc.contents = doc.createNode({});
+        // Validate references with the full document context and the default alias limit.
+        // Cycles are valid YAML, but not a usable model configuration; reject before expansion.
+        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 all references before replacing any nodes (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");
+        if (doc.hasIn(["providers"]) && !YAML.isMap(doc.getIn(["providers"]))) {
+            throw new Error("expected providers to be a mapping");
+        }
+        return doc;
+    }
+    catch (error) {
+        throw new Error(`${file} has invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/** Validate the emitted document before any backup or write. */
+function serializeModelsDocument(file, doc) {
+    try {
+        const text = doc.toString();
+        YAML.parse(text);
+        return text;
+    }
+    catch (error) {
+        throw new Error(`${file} has invalid YAML: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 /**
  * Oh My Pi: providers live in ~/.omp/agent/models.yml (models.yaml fallback).
  * YAML Document round-trip preserves existing comments and unrelated providers.
@@ -24,13 +69,8 @@ export const omp = {
         // Respect an existing models.yaml if models.yml is absent (omp precedence: yml then yaml).
         const file = !fs.existsSync(modelsYml) && fs.existsSync(modelsYaml) ? modelsYaml : modelsYml;
         const text = readTextIfExists(file);
-        const doc = text ? YAML.parseDocument(text) : new YAML.Document({});
-        if (doc.errors.length) {
-            throw new Error(`${file} has YAML errors; refusing to rewrite: ${doc.errors[0]?.message}`);
-        }
-        if (doc.contents == null)
-            doc.contents = doc.createNode({});
-        const prev = doc.getIn(["providers", provider.id])?.toJSON?.();
+        const doc = parseModelsDocument(file, text);
+        const prev = doc.getIn(["providers", provider.id])?.toJS(doc);
         const anthropic = provider.protocol === "anthropic";
         const api = apiValue(provider.protocol, provider.openaiApi, entryApi(prev ?? {}));
         const baseUrl = sdkBaseUrl(provider.protocol, provider.baseUrl);
@@ -79,10 +119,11 @@ export const omp = {
         else {
             doc.setIn(at, doc.createNode(entry));
         }
+        const output = serializeModelsDocument(file, doc);
         const backup = backupFile(file);
         if (backup)
             notes.push(`backup: ${backup}`);
-        writeFileAtomic(file, doc.toString());
+        writeFileAtomic(file, output);
         notes.push(`select in omp with: omp --model ${provider.id}/${provider.defaultModel}`);
         return { app: this.id, changed: [file], notes };
     },
@@ -90,19 +131,17 @@ export const omp = {
         const file = fs.existsSync(modelsYml) ? modelsYml : fs.existsSync(modelsYaml) ? modelsYaml : undefined;
         if (!file)
             return { app: this.id, changed: [], notes: [], skipped: "no models.yml" };
-        const doc = YAML.parseDocument(readTextIfExists(file) ?? "");
-        if (doc.errors.length) {
-            throw new Error(`${file} has YAML errors; refusing to rewrite: ${doc.errors[0]?.message}`);
-        }
+        const doc = parseModelsDocument(file, readTextIfExists(file));
         if (!doc.hasIn(["providers", provider.id])) {
             return { app: this.id, changed: [], notes: [], skipped: `no providers.${provider.id} entry` };
         }
         doc.deleteIn(["providers", provider.id]);
         const notes = [];
+        const output = serializeModelsDocument(file, doc);
         const backup = backupFile(file);
         if (backup)
             notes.push(`backup: ${backup}`);
-        writeFileAtomic(file, doc.toString());
+        writeFileAtomic(file, output);
         return { app: this.id, changed: [file], notes };
     },
     current() {

package/dist/targets/pistyle.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { backupFile, home, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
+import { backupFile, home, writeFileAtomic } from "../fsutil.js";
+import { editJsoncObject, isJsonObject, readJsoncObject } from "../jsonc.js";
 import { looksLikeEnvName } from "../slug.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. */
@@ -14,6 +15,28 @@ const OWNED_MODEL_KEYS = [
     "maxTokens",
     "cost",
 ];
+function readModels(file) {
+    const document = readJsoncObject(file);
+    const providers = document.value.providers;
+    if (providers !== undefined) {
+        if (!isJsonObject(providers))
+            throw new Error(`${file}: expected providers to be a JSON object`);
+        for (const entry of Object.values(providers)) {
+            if (!isJsonObject(entry))
+                throw new Error(`${file}: expected every provider entry to be a JSON object`);
+        }
+    }
+    return { ...document, value: document.value };
+}
+function readSettings(file) {
+    const document = readJsoncObject(file);
+    for (const key of ["defaultProvider", "defaultModel"]) {
+        if (document.value[key] !== undefined && typeof document.value[key] !== "string") {
+            throw new Error(`${file}: expected ${key} to be a string`);
+        }
+    }
+    return { ...document, value: document.value };
+}
 /**
  * pi-family agents (pi, prime-agent) share the same config layout:
  *   <dir>/models.json   — { providers: { <id>: { baseUrl, apiKey, api, models[] } } }
@@ -50,14 +73,14 @@ export function piStyleTarget(opts) {
             const modelsFile = path.join(dir, "models.json");
             const settingsFile = path.join(dir, "settings.json");
             const notes = [];
-            const modelsConfig = readJsonIfExists(modelsFile) ?? {};
+            // Validate both files before preparing any writes, including a malformed settings file.
+            const modelsDocument = readModels(modelsFile);
+            const settingsDocument = readSettings(settingsFile);
+            const modelsConfig = { ...modelsDocument.value };
             const providers = { ...modelsConfig.providers };
             // 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 existing = providers[provider.id];
-            const prev = (existing && typeof existing === "object" && !Array.isArray(existing)
-                ? existing
-                : {});
+            const prev = providers[provider.id] ?? {};
             const api = apiValue(provider.protocol, provider.openaiApi, entryApi(prev));
             const baseUrl = sdkBaseUrl(provider.protocol, provider.baseUrl);
             const models = mergeModels(prev.models, provider.models.map((m) => ({
@@ -93,60 +116,70 @@ export function piStyleTarget(opts) {
                 models,
             };
             modelsConfig.providers = providers;
+            const settings = {
+                ...settingsDocument.value,
+                defaultProvider: provider.id,
+                defaultModel: provider.defaultModel,
+            };
+            const modelsText = editJsoncObject(modelsDocument, modelsConfig);
+            const settingsText = editJsoncObject(settingsDocument, settings);
             const modelsBackup = backupFile(modelsFile);
             if (modelsBackup)
                 notes.push(`backup: ${modelsBackup}`);
-            writeFileAtomic(modelsFile, JSON.stringify(modelsConfig, null, 2) + "\n");
-            const settings = readJsonIfExists(settingsFile) ?? {};
-            settings.defaultProvider = provider.id;
-            settings.defaultModel = provider.defaultModel;
+            writeFileAtomic(modelsFile, modelsText);
             const settingsBackup = backupFile(settingsFile);
             if (settingsBackup)
                 notes.push(`backup: ${settingsBackup}`);
-            writeFileAtomic(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+            writeFileAtomic(settingsFile, settingsText);
             return { app: opts.id, changed: [modelsFile, settingsFile], notes };
         },
         async prune(provider) {
             const dir = resolveDir();
             const modelsFile = path.join(dir, "models.json");
             const settingsFile = path.join(dir, "settings.json");
-            const modelsConfig = readJsonIfExists(modelsFile);
-            const providers = modelsConfig?.providers;
-            if (!modelsConfig || !providers?.[provider.id]) {
+            const modelsDocument = readModels(modelsFile);
+            const settingsDocument = readSettings(settingsFile);
+            const providers = { ...modelsDocument.value.providers };
+            if (!Object.hasOwn(providers, provider.id)) {
                 return { app: opts.id, changed: [], notes: [], skipped: `no providers.${provider.id} entry` };
             }
             delete providers[provider.id];
+            const settings = { ...settingsDocument.value };
+            const resetDefault = settings.defaultProvider === provider.id;
+            if (resetDefault) {
+                delete settings.defaultProvider;
+                delete settings.defaultModel;
+            }
+            const modelsText = editJsoncObject(modelsDocument, { ...modelsDocument.value, providers });
+            const settingsText = resetDefault ? editJsoncObject(settingsDocument, settings) : undefined;
             const notes = [];
             const changed = [modelsFile];
             const modelsBackup = backupFile(modelsFile);
             if (modelsBackup)
                 notes.push(`backup: ${modelsBackup}`);
-            writeFileAtomic(modelsFile, JSON.stringify(modelsConfig, null, 2) + "\n");
-            const settings = readJsonIfExists(settingsFile);
-            if (settings?.defaultProvider === provider.id) {
-                delete settings.defaultProvider;
-                delete settings.defaultModel;
+            writeFileAtomic(modelsFile, modelsText);
+            if (settingsText !== undefined) {
                 const settingsBackup = backupFile(settingsFile);
                 if (settingsBackup)
                     notes.push(`backup: ${settingsBackup}`);
-                writeFileAtomic(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+                writeFileAtomic(settingsFile, settingsText);
                 changed.push(settingsFile);
                 notes.push("default model reset (was pointing at this provider)");
             }
             return { app: opts.id, changed, notes };
         },
         current() {
-            const settings = readJsonIfExists(path.join(resolveDir(), "settings.json"));
+            const settings = readSettings(path.join(resolveDir(), "settings.json")).value;
             if (!settings?.defaultProvider)
                 return undefined;
             return `${settings.defaultProvider} · ${settings.defaultModel ?? "?"}`;
         },
         candidates() {
             const dir = resolveDir();
-            const mc = readJsonIfExists(path.join(dir, "models.json"));
-            if (!mc?.providers)
+            const mc = readModels(path.join(dir, "models.json")).value;
+            const settings = readSettings(path.join(dir, "settings.json")).value;
+            if (!mc.providers)
                 return [];
-            const settings = readJsonIfExists(path.join(dir, "settings.json"));
             const self = opts.id;
             return Object.entries(mc.providers).flatMap(([id, entry]) => {
                 if (!entry || typeof entry.baseUrl !== "string")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentsw",
-  "version": "0.6.1",
+  "version": "0.6.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": {
@@ -41,6 +41,7 @@
   },
   "dependencies": {
     "commander": "^15.0.0",
+    "jsonc-parser": "^3.3.1",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2",
     "smol-toml": "^1.8.0",