waypoi 0.0.0

package/dist/src/providers/repository.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalProviderModelId = canonicalProviderModelId;
+exports.loadProviderStore = loadProviderStore;
+exports.saveProviderStore = saveProviderStore;
+exports.listProviders = listProviders;
+exports.getProviderById = getProviderById;
+exports.setProviderEnabled = setProviderEnabled;
+exports.upsertProviders = upsertProviders;
+exports.upsertProvider = upsertProvider;
+exports.updateProvider = updateProvider;
+exports.deleteProvider = deleteProvider;
+exports.listProviderModels = listProviderModels;
+exports.getProviderModel = getProviderModel;
+exports.resolveProviderModelRef = resolveProviderModelRef;
+exports.upsertProviderModel = upsertProviderModel;
+exports.updateProviderModel = updateProviderModel;
+exports.deleteProviderModel = deleteProviderModel;
+exports.setProviderModelEnabled = setProviderModelEnabled;
+exports.setProviderModelApiKey = setProviderModelApiKey;
+exports.setProviderModelInsecureTls = setProviderModelInsecureTls;
+exports.getEffectiveModelInsecureTls = getEffectiveModelInsecureTls;
+exports.normalizeDomainSuffixes = normalizeDomainSuffixes;
+const files_1 = require("../storage/files");
+const CURRENT_VERSION = 3;
+function defaultStore() {
+    return {
+        version: CURRENT_VERSION,
+        updatedAt: new Date().toISOString(),
+        providers: [],
+    };
+}
+function canonicalProviderModelId(providerId, modelId) {
+    return `${providerId}/${modelId}`;
+}
+async function loadProviderStore(paths) {
+    const store = await (0, files_1.readJsonFile)(paths.providersPath, defaultStore());
+    if (!Array.isArray(store.providers)) {
+        return defaultStore();
+    }
+    const providers = store.providers.map(normalizeProviderRecord);
+    return {
+        version: Number.isFinite(store.version) ? store.version : CURRENT_VERSION,
+        updatedAt: typeof store.updatedAt === "string" ? store.updatedAt : new Date().toISOString(),
+        providers,
+    };
+}
+async function saveProviderStore(paths, providers) {
+    const next = {
+        version: CURRENT_VERSION,
+        updatedAt: new Date().toISOString(),
+        providers: providers.map(normalizeProviderRecord),
+    };
+    await (0, files_1.writeJsonFile)(paths.providersPath, next);
+}
+async function listProviders(paths) {
+    const store = await loadProviderStore(paths);
+    return [...store.providers].sort((a, b) => a.id.localeCompare(b.id));
+}
+async function getProviderById(paths, providerId) {
+    const providers = await listProviders(paths);
+    return providers.find((provider) => provider.id === providerId) ?? null;
+}
+async function setProviderEnabled(paths, providerId, enabled) {
+    const store = await loadProviderStore(paths);
+    const index = store.providers.findIndex((provider) => provider.id === providerId);
+    if (index === -1) {
+        return null;
+    }
+    const updated = {
+        ...store.providers[index],
+        enabled,
+    };
+    store.providers[index] = normalizeProviderRecord(updated);
+    await saveProviderStore(paths, store.providers);
+    return store.providers[index];
+}
+async function upsertProviders(paths, providers) {
+    const existing = await loadProviderStore(paths);
+    const byId = new Map(existing.providers.map((provider) => [provider.id, normalizeProviderRecord(provider)]));
+    for (const provider of providers) {
+        const normalized = normalizeProviderRecord(provider);
+        const prev = byId.get(provider.id);
+        if (!prev) {
+            byId.set(provider.id, normalized);
+            continue;
+        }
+        const mergedByModelId = new Map(prev.models.map((model) => [model.providerModelId, model]));
+        for (const model of normalized.models) {
+            const previousModel = mergedByModelId.get(model.providerModelId);
+            mergedByModelId.set(model.providerModelId, normalizeProviderModelRecord({
+                ...model,
+                enabled: previousModel?.enabled ?? model.enabled,
+                apiKey: model.apiKey ?? previousModel?.apiKey,
+                aliases: model.aliases?.length ? model.aliases : previousModel?.aliases,
+            }));
+        }
+        byId.set(provider.id, normalizeProviderRecord({
+            ...normalized,
+            enabled: prev.enabled,
+            apiKey: normalized.apiKey ?? prev.apiKey,
+            insecureTls: provider.insecureTls ?? prev.insecureTls,
+            autoInsecureTlsDomains: provider.autoInsecureTlsDomains ?? prev.autoInsecureTlsDomains,
+            models: Array.from(mergedByModelId.values()),
+        }));
+    }
+    await saveProviderStore(paths, Array.from(byId.values()));
+}
+async function upsertProvider(paths, provider) {
+    const existing = await loadProviderStore(paths);
+    const index = existing.providers.findIndex((entry) => entry.id === provider.id);
+    if (index === -1) {
+        const normalized = normalizeProviderRecord(provider);
+        existing.providers.push(normalized);
+        await saveProviderStore(paths, existing.providers);
+        return normalized;
+    }
+    const prev = normalizeProviderRecord(existing.providers[index]);
+    const next = normalizeProviderRecord({
+        ...provider,
+        enabled: prev.enabled,
+        apiKey: provider.apiKey ?? prev.apiKey,
+        insecureTls: provider.insecureTls ?? prev.insecureTls,
+        autoInsecureTlsDomains: provider.autoInsecureTlsDomains ?? prev.autoInsecureTlsDomains,
+    });
+    existing.providers[index] = next;
+    await saveProviderStore(paths, existing.providers);
+    return next;
+}
+async function updateProvider(paths, providerId, patch) {
+    const store = await loadProviderStore(paths);
+    const index = store.providers.findIndex((provider) => provider.id === providerId);
+    if (index === -1) {
+        return null;
+    }
+    const current = normalizeProviderRecord(store.providers[index]);
+    const updated = normalizeProviderRecord({
+        ...current,
+        ...patch,
+        id: providerId,
+        models: patch.models ?? current.models,
+    });
+    store.providers[index] = updated;
+    await saveProviderStore(paths, store.providers);
+    return updated;
+}
+async function deleteProvider(paths, providerId) {
+    const store = await loadProviderStore(paths);
+    const index = store.providers.findIndex((provider) => provider.id === providerId);
+    if (index === -1) {
+        return null;
+    }
+    const [removed] = store.providers.splice(index, 1);
+    await saveProviderStore(paths, store.providers);
+    return normalizeProviderRecord(removed);
+}
+async function listProviderModels(paths, providerId) {
+    const provider = await getProviderById(paths, providerId);
+    if (!provider) {
+        return null;
+    }
+    return [...provider.models].sort((a, b) => a.modelId.localeCompare(b.modelId));
+}
+async function getProviderModel(paths, providerId, modelRef) {
+    const resolved = await resolveProviderModelRef(paths, providerId, modelRef);
+    if (!resolved) {
+        return null;
+    }
+    return resolved.model;
+}
+async function resolveProviderModelRef(paths, providerId, modelRef) {
+    const provider = await getProviderById(paths, providerId);
+    if (!provider) {
+        return null;
+    }
+    const normalizedRef = modelRef.trim();
+    const candidates = provider.models
+        .map((model, modelIndex) => ({ model, modelIndex }))
+        .filter(({ model }) => {
+        if (model.providerModelId === normalizedRef) {
+            return true;
+        }
+        if (canonicalProviderModelId(providerId, model.modelId) === normalizedRef) {
+            return true;
+        }
+        if (model.modelId === normalizedRef) {
+            return true;
+        }
+        return Boolean(model.aliases?.includes(normalizedRef));
+    });
+    if (candidates.length !== 1) {
+        return null;
+    }
+    return {
+        provider,
+        model: candidates[0].model,
+        modelIndex: candidates[0].modelIndex,
+    };
+}
+async function upsertProviderModel(paths, providerId, model) {
+    const store = await loadProviderStore(paths);
+    const providerIndex = store.providers.findIndex((provider) => provider.id === providerId);
+    if (providerIndex === -1) {
+        return null;
+    }
+    const provider = normalizeProviderRecord(store.providers[providerIndex]);
+    const normalizedModel = normalizeProviderModelRecord({
+        ...model,
+        providerId,
+    });
+    const modelIndex = provider.models.findIndex((entry) => entry.providerModelId === normalizedModel.providerModelId);
+    if (modelIndex === -1) {
+        provider.models.push(normalizedModel);
+        store.providers[providerIndex] = provider;
+        await saveProviderStore(paths, store.providers);
+        return { provider, created: true };
+    }
+    provider.models[modelIndex] = {
+        ...provider.models[modelIndex],
+        ...normalizedModel,
+        providerId,
+    };
+    store.providers[providerIndex] = provider;
+    await saveProviderStore(paths, store.providers);
+    return { provider, created: false };
+}
+async function updateProviderModel(paths, providerId, modelRef, patch) {
+    const store = await loadProviderStore(paths);
+    const providerIndex = store.providers.findIndex((provider) => provider.id === providerId);
+    if (providerIndex === -1) {
+        return null;
+    }
+    const provider = normalizeProviderRecord(store.providers[providerIndex]);
+    const matchingIndexes = provider.models.flatMap((model, index) => {
+        if (model.providerModelId === modelRef) {
+            return [index];
+        }
+        if (model.modelId === modelRef) {
+            return [index];
+        }
+        if (model.aliases?.includes(modelRef)) {
+            return [index];
+        }
+        return [];
+    });
+    if (matchingIndexes.length !== 1) {
+        return null;
+    }
+    const modelIndex = matchingIndexes[0];
+    const updated = normalizeProviderModelRecord({
+        ...provider.models[modelIndex],
+        ...patch,
+        providerId,
+    });
+    provider.models[modelIndex] = updated;
+    store.providers[providerIndex] = provider;
+    await saveProviderStore(paths, store.providers);
+    return updated;
+}
+async function deleteProviderModel(paths, providerId, modelRef) {
+    const store = await loadProviderStore(paths);
+    const providerIndex = store.providers.findIndex((provider) => provider.id === providerId);
+    if (providerIndex === -1) {
+        return null;
+    }
+    const provider = normalizeProviderRecord(store.providers[providerIndex]);
+    const matchingIndexes = provider.models.flatMap((model, index) => {
+        if (model.providerModelId === modelRef) {
+            return [index];
+        }
+        if (model.modelId === modelRef) {
+            return [index];
+        }
+        if (model.aliases?.includes(modelRef)) {
+            return [index];
+        }
+        return [];
+    });
+    if (matchingIndexes.length !== 1) {
+        return null;
+    }
+    const modelIndex = matchingIndexes[0];
+    const [removed] = provider.models.splice(modelIndex, 1);
+    store.providers[providerIndex] = provider;
+    await saveProviderStore(paths, store.providers);
+    return removed;
+}
+async function setProviderModelEnabled(paths, providerId, modelRef, enabled) {
+    return updateProviderModel(paths, providerId, modelRef, { enabled });
+}
+async function setProviderModelApiKey(paths, providerId, modelRef, apiKey) {
+    return updateProviderModel(paths, providerId, modelRef, { apiKey });
+}
+async function setProviderModelInsecureTls(paths, providerId, modelRef, insecureTls) {
+    return updateProviderModel(paths, providerId, modelRef, { insecureTls });
+}
+function getEffectiveModelInsecureTls(provider, model) {
+    return model.insecureTls ?? provider.insecureTls ?? false;
+}
+function normalizeProviderRecord(provider) {
+    const models = Array.isArray(provider.models) ? provider.models.map((model) => normalizeProviderModelRecord({
+        ...model,
+        providerId: provider.id,
+    })) : [];
+    return {
+        ...provider,
+        id: provider.id,
+        insecureTls: provider.insecureTls === true,
+        autoInsecureTlsDomains: normalizeDomainSuffixes(provider.autoInsecureTlsDomains),
+        models,
+    };
+}
+function normalizeProviderModelRecord(model) {
+    const aliases = normalizeAliases(model.aliases);
+    const providerId = model.providerId;
+    const modelId = model.modelId.trim();
+    return {
+        ...model,
+        providerId,
+        modelId,
+        providerModelId: model.providerModelId || canonicalProviderModelId(providerId, modelId),
+        aliases,
+        enabled: model.enabled ?? true,
+    };
+}
+function normalizeAliases(aliases) {
+    if (!Array.isArray(aliases)) {
+        return [];
+    }
+    const dedup = new Set();
+    for (const alias of aliases) {
+        const normalized = alias.trim();
+        if (normalized) {
+            dedup.add(normalized);
+        }
+    }
+    return Array.from(dedup);
+}
+function normalizeDomainSuffixes(domains) {
+    if (!Array.isArray(domains)) {
+        return [];
+    }
+    const dedup = new Set();
+    for (const domain of domains) {
+        let normalized = domain.trim().toLowerCase();
+        if (!normalized) {
+            continue;
+        }
+        if (normalized.startsWith("*.")) {
+            normalized = normalized.slice(2);
+        }
+        if (normalized.startsWith(".")) {
+            normalized = normalized.slice(1);
+        }
+        if (!normalized) {
+            continue;
+        }
+        dedup.add(normalized);
+    }
+    return Array.from(dedup);
+}

package/dist/src/providers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });