@bridge_gpt/mcp-server 0.2.58 → 0.2.60

package/build/model-routing-preferences.js

@@ -0,0 +1,99 @@
+/** Personal, secret-free provider preferences. Read afresh for every tool call. */
+import { promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const MAX_BYTES = 64 * 1024;
+const PROVIDERS = new Set(["openai", "anthropic", "gemini"]);
+const FEATURES = new Set(["review_ticket", "second_opinion", "council"]);
+const warned = new Set();
+const defaultIO = {
+    lstat: path => fs.lstat(path),
+    readFile: path => fs.readFile(path),
+    stderr: message => console.error(message),
+    platform: process.platform,
+    uid: typeof process.getuid === "function" ? process.getuid() : undefined,
+};
+export function modelRoutingPreferencesPath(home = homedir()) {
+    return join(home, ".config", "bridge", "model-routing.json");
+}
+function warn(category, io) {
+    if (!warned.has(category)) {
+        warned.add(category);
+        io.stderr(`Bridge model routing preference ignored (${category}).`);
+    }
+    return { providers: [], source: "automatic", warning: category };
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value : null;
+}
+function featureMap(value) {
+    const obj = record(value);
+    if (!obj)
+        return null;
+    const out = {};
+    for (const [key, raw] of Object.entries(obj)) {
+        if (!FEATURES.has(key) || !Array.isArray(raw) || raw.length > 3)
+            return null;
+        const providers = [];
+        for (const item of raw) {
+            if (typeof item !== "string")
+                return null;
+            const provider = item.trim().toLowerCase();
+            if (!PROVIDERS.has(provider) || providers.includes(provider))
+                return null;
+            providers.push(provider);
+        }
+        out[key] = providers;
+    }
+    return out;
+}
+/** Resolve an exact repository feature key over the machine key. */
+export async function readModelRoutingPreference(repoName, feature, path = modelRoutingPreferencesPath(), io = defaultIO) {
+    if (!FEATURES.has(feature) || typeof repoName !== "string" || !repoName)
+        return warn("invalid_file", io);
+    let stat;
+    try {
+        stat = await io.lstat(path);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { providers: [], source: "automatic" };
+        return warn("unreadable_file", io);
+    }
+    if (!stat.isFile() || stat.size > MAX_BYTES || stat.size < 0 ||
+        (io.platform !== "win32" && ((stat.mode & 0o022) !== 0 ||
+            (io.uid !== undefined && stat.uid !== io.uid)))) {
+        return warn("unsafe_file", io);
+    }
+    let data;
+    try {
+        const raw = await io.readFile(path);
+        const decoded = typeof raw === "string" ? raw : new TextDecoder("utf-8", { fatal: true }).decode(raw);
+        data = JSON.parse(decoded);
+    }
+    catch {
+        return warn("unreadable_file", io);
+    }
+    const root = record(data);
+    if (!root || root.version !== 1 || (root.repositories !== undefined && !record(root.repositories)))
+        return warn("invalid_file", io);
+    const machine = featureMap(root.defaults ?? {});
+    if (!machine)
+        return warn("invalid_file", io);
+    const repositories = record(root.repositories ?? {});
+    if (Object.values(repositories).some(value => !featureMap(value)))
+        return warn("invalid_file", io);
+    const repository = Object.hasOwn(repositories, repoName) ? featureMap(repositories[repoName]) : {};
+    if (!repository)
+        return warn("invalid_file", io);
+    if (Object.hasOwn(repository, feature))
+        return {
+            providers: repository[feature], source: repository[feature].length ? "repository" : "automatic",
+        };
+    if (Object.hasOwn(machine, feature))
+        return {
+            providers: machine[feature], source: machine[feature].length ? "machine" : "automatic",
+        };
+    return { providers: [], source: "automatic" };
+}