382 lines
13 KiB
TypeScript
382 lines
13 KiB
TypeScript
import {
|
|
PROVIDER_DEFINITIONS,
|
|
getProviderDefinition,
|
|
} from '../../shared/providers/registry';
|
|
import type {
|
|
ProviderAccount,
|
|
ProviderConfig,
|
|
ProviderDefinition,
|
|
} from '../../shared/providers/types';
|
|
import type { UserSyncProviderAccount } from '../../../shared/user-sync';
|
|
import { ensureProviderStoreMigrated } from './provider-migration';
|
|
import {
|
|
deleteProviderAccount,
|
|
getDefaultProviderAccountId,
|
|
getProviderAccount,
|
|
listProviderAccounts,
|
|
providerAccountToConfig,
|
|
providerConfigToAccount,
|
|
saveProviderAccount,
|
|
setDefaultProviderAccount,
|
|
} from './provider-store';
|
|
import {
|
|
deleteApiKey,
|
|
deleteProvider,
|
|
getApiKey,
|
|
hasApiKey,
|
|
setDefaultProvider,
|
|
storeApiKey,
|
|
} from '../../utils/secure-storage';
|
|
import type { ProviderWithKeyInfo } from '../../shared/providers/types';
|
|
import { logger } from '../../utils/logger';
|
|
|
|
function maskApiKey(apiKey: string | null): string | null {
|
|
if (!apiKey) return null;
|
|
if (apiKey.length > 12) {
|
|
return `${apiKey.substring(0, 4)}${'*'.repeat(apiKey.length - 8)}${apiKey.substring(apiKey.length - 4)}`;
|
|
}
|
|
return '*'.repeat(apiKey.length);
|
|
}
|
|
|
|
const legacyProviderApiWarned = new Set<string>();
|
|
|
|
function logLegacyProviderApiUsage(method: string, replacement: string): void {
|
|
if (legacyProviderApiWarned.has(method)) {
|
|
return;
|
|
}
|
|
legacyProviderApiWarned.add(method);
|
|
logger.warn(
|
|
`[provider-migration] Legacy provider API "${method}" is deprecated. Migrate to "${replacement}".`,
|
|
);
|
|
}
|
|
|
|
function normalizeSyncedMetadata(metadata: Record<string, unknown>): ProviderAccount['metadata'] {
|
|
const result: ProviderAccount['metadata'] = {};
|
|
if (typeof metadata.region === 'string' && metadata.region.trim()) {
|
|
result.region = metadata.region.trim();
|
|
}
|
|
if (typeof metadata.email === 'string' && metadata.email.trim()) {
|
|
result.email = metadata.email.trim();
|
|
}
|
|
if (typeof metadata.resourceUrl === 'string' && metadata.resourceUrl.trim()) {
|
|
result.resourceUrl = metadata.resourceUrl.trim();
|
|
}
|
|
if (Array.isArray(metadata.customModels)) {
|
|
const customModels = metadata.customModels
|
|
.filter((model): model is string => typeof model === 'string' && Boolean(model.trim()))
|
|
.map((model) => model.trim());
|
|
if (customModels.length > 0) {
|
|
result.customModels = customModels;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
export class ProviderService {
|
|
async listVendors(): Promise<ProviderDefinition[]> {
|
|
return PROVIDER_DEFINITIONS;
|
|
}
|
|
|
|
async listAccounts(): Promise<ProviderAccount[]> {
|
|
await ensureProviderStoreMigrated();
|
|
return listProviderAccounts();
|
|
}
|
|
|
|
async getAccount(accountId: string): Promise<ProviderAccount | null> {
|
|
await ensureProviderStoreMigrated();
|
|
return getProviderAccount(accountId);
|
|
}
|
|
|
|
async getDefaultAccountId(): Promise<string | undefined> {
|
|
await ensureProviderStoreMigrated();
|
|
return getDefaultProviderAccountId();
|
|
}
|
|
|
|
async createAccount(account: ProviderAccount, apiKey?: string): Promise<ProviderAccount> {
|
|
await ensureProviderStoreMigrated();
|
|
await saveProviderAccount(account);
|
|
if (apiKey !== undefined && apiKey.trim()) {
|
|
await storeApiKey(account.id, apiKey.trim());
|
|
}
|
|
return (await getProviderAccount(account.id)) ?? account;
|
|
}
|
|
|
|
async updateAccount(
|
|
accountId: string,
|
|
patch: Partial<ProviderAccount>,
|
|
apiKey?: string,
|
|
): Promise<ProviderAccount> {
|
|
await ensureProviderStoreMigrated();
|
|
const existing = await getProviderAccount(accountId);
|
|
if (!existing) {
|
|
throw new Error('Provider account not found');
|
|
}
|
|
|
|
const nextAccount: ProviderAccount = {
|
|
...existing,
|
|
...patch,
|
|
id: accountId,
|
|
updatedAt: patch.updatedAt ?? new Date().toISOString(),
|
|
};
|
|
|
|
await saveProviderAccount(nextAccount);
|
|
if (apiKey !== undefined) {
|
|
const trimmedKey = apiKey.trim();
|
|
if (trimmedKey) {
|
|
await storeApiKey(accountId, trimmedKey);
|
|
} else {
|
|
await deleteApiKey(accountId);
|
|
}
|
|
}
|
|
|
|
return (await getProviderAccount(accountId)) ?? nextAccount;
|
|
}
|
|
|
|
async upsertSyncedAccountMetadata(account: UserSyncProviderAccount): Promise<ProviderAccount> {
|
|
await ensureProviderStoreMigrated();
|
|
const existing = await getProviderAccount(account.id);
|
|
const now = new Date().toISOString();
|
|
const nextAccount: ProviderAccount = {
|
|
id: account.id,
|
|
vendorId: account.vendorId as ProviderAccount['vendorId'],
|
|
label: account.label,
|
|
authMode: account.authMode as ProviderAccount['authMode'],
|
|
baseUrl: account.baseUrl,
|
|
apiProtocol: account.apiProtocol as ProviderAccount['apiProtocol'] | undefined,
|
|
headers: existing?.headers,
|
|
model: account.model,
|
|
fallbackModels: account.fallbackModels,
|
|
fallbackAccountIds: account.fallbackAccountIds,
|
|
enabled: account.enabled,
|
|
isDefault: account.isDefault,
|
|
metadata: normalizeSyncedMetadata(account.metadata ?? {}),
|
|
createdAt: existing?.createdAt ?? now,
|
|
updatedAt: account.updatedAt ?? now,
|
|
};
|
|
|
|
await saveProviderAccount(nextAccount);
|
|
if (nextAccount.isDefault) {
|
|
await this.setDefaultAccount(nextAccount.id);
|
|
}
|
|
return (await getProviderAccount(nextAccount.id)) ?? nextAccount;
|
|
}
|
|
|
|
async deleteAccount(accountId: string): Promise<boolean> {
|
|
await ensureProviderStoreMigrated();
|
|
return deleteProvider(accountId);
|
|
}
|
|
|
|
/** Internal: list providers in the legacy ProviderConfig shape. */
|
|
async _listProvidersFromAccountsInternal(): Promise<ProviderConfig[]> {
|
|
const accounts = await this.listAccounts();
|
|
return accounts.map(providerAccountToConfig);
|
|
}
|
|
|
|
/** Internal: list providers with hasKey/keyMasked metadata. */
|
|
async _listProvidersWithKeyInfoInternal(): Promise<ProviderWithKeyInfo[]> {
|
|
const providers = await this._listProvidersFromAccountsInternal();
|
|
const results: ProviderWithKeyInfo[] = [];
|
|
for (const provider of providers) {
|
|
const apiKey = await getApiKey(provider.id);
|
|
results.push({
|
|
...provider,
|
|
hasKey: !!apiKey,
|
|
keyMasked: maskApiKey(apiKey),
|
|
});
|
|
}
|
|
return results;
|
|
}
|
|
|
|
/** Internal: resolve a single provider in the legacy ProviderConfig shape. */
|
|
async _getProviderInternal(providerId: string): Promise<ProviderConfig | null> {
|
|
await ensureProviderStoreMigrated();
|
|
const account = await getProviderAccount(providerId);
|
|
return account ? providerAccountToConfig(account) : null;
|
|
}
|
|
|
|
/** Internal: upsert a legacy provider config. */
|
|
async _saveProviderInternal(config: ProviderConfig): Promise<void> {
|
|
await ensureProviderStoreMigrated();
|
|
const account = providerConfigToAccount(config);
|
|
const existing = await getProviderAccount(config.id);
|
|
if (existing) {
|
|
await this.updateAccount(config.id, account);
|
|
return;
|
|
}
|
|
await this.createAccount(account);
|
|
}
|
|
|
|
/** Internal: delete a provider account by id. */
|
|
async _deleteProviderInternal(providerId: string): Promise<boolean> {
|
|
await ensureProviderStoreMigrated();
|
|
await deleteProviderAccount(providerId);
|
|
await deleteApiKey(providerId);
|
|
return true;
|
|
}
|
|
|
|
/** Internal: set default account without warning. */
|
|
async _setDefaultProviderInternal(providerId: string): Promise<void> {
|
|
await this.setDefaultAccount(providerId);
|
|
}
|
|
|
|
/** Internal: read default account id without warning. */
|
|
async _getDefaultProviderInternal(): Promise<string | undefined> {
|
|
return this.getDefaultAccountId();
|
|
}
|
|
|
|
/** Internal: store an account's api key without warning. */
|
|
async _setProviderApiKeyInternal(providerId: string, apiKey: string): Promise<boolean> {
|
|
return storeApiKey(providerId, apiKey);
|
|
}
|
|
|
|
/** Internal: read an account's api key without warning. */
|
|
async _getProviderApiKeyInternal(providerId: string): Promise<string | null> {
|
|
return getApiKey(providerId);
|
|
}
|
|
|
|
/** Internal: delete an account's api key without warning. */
|
|
async _deleteProviderApiKeyInternal(providerId: string): Promise<boolean> {
|
|
return deleteApiKey(providerId);
|
|
}
|
|
|
|
/** Internal: check if an account has a stored api key. */
|
|
async _hasProviderApiKeyInternal(providerId: string): Promise<boolean> {
|
|
return hasApiKey(providerId);
|
|
}
|
|
|
|
/** Return per-account API key status for the account API surface. */
|
|
async listAccountsKeyInfo(): Promise<Array<{ accountId: string; hasKey: boolean; keyMasked: string | null }>> {
|
|
const accounts = await this.listAccounts();
|
|
const results: Array<{ accountId: string; hasKey: boolean; keyMasked: string | null }> = [];
|
|
for (const account of accounts) {
|
|
const apiKey = await getApiKey(account.id);
|
|
results.push({
|
|
accountId: account.id,
|
|
hasKey: !!apiKey,
|
|
keyMasked: maskApiKey(apiKey),
|
|
});
|
|
}
|
|
return results;
|
|
}
|
|
|
|
/** Read an account's API key. */
|
|
async getAccountApiKey(accountId: string): Promise<string | null> {
|
|
return this._getProviderApiKeyInternal(accountId);
|
|
}
|
|
|
|
/** Check whether an account has an API key stored. */
|
|
async hasAccountApiKey(accountId: string): Promise<boolean> {
|
|
return this._hasProviderApiKeyInternal(accountId);
|
|
}
|
|
|
|
/** Delete only an account's stored API key while keeping its model configuration. */
|
|
async deleteAccountApiKey(accountId: string): Promise<boolean> {
|
|
await ensureProviderStoreMigrated();
|
|
return deleteApiKey(accountId);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use listAccounts() and map account data in callers.
|
|
*/
|
|
async listLegacyProviders(): Promise<ProviderConfig[]> {
|
|
logLegacyProviderApiUsage('listLegacyProviders', 'listAccounts');
|
|
return this._listProvidersFromAccountsInternal();
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use listAccountsKeyInfo() + the account snapshot API.
|
|
*/
|
|
async listLegacyProvidersWithKeyInfo(): Promise<ProviderWithKeyInfo[]> {
|
|
logLegacyProviderApiUsage('listLegacyProvidersWithKeyInfo', 'listAccountsKeyInfo');
|
|
return this._listProvidersWithKeyInfoInternal();
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use getAccount(accountId).
|
|
*/
|
|
async getLegacyProvider(providerId: string): Promise<ProviderConfig | null> {
|
|
logLegacyProviderApiUsage('getLegacyProvider', 'getAccount');
|
|
return this._getProviderInternal(providerId);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use createAccount()/updateAccount().
|
|
*/
|
|
async saveLegacyProvider(config: ProviderConfig): Promise<void> {
|
|
logLegacyProviderApiUsage('saveLegacyProvider', 'createAccount/updateAccount');
|
|
return this._saveProviderInternal(config);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use deleteAccount(accountId).
|
|
*/
|
|
async deleteLegacyProvider(providerId: string): Promise<boolean> {
|
|
logLegacyProviderApiUsage('deleteLegacyProvider', 'deleteAccount');
|
|
return this._deleteProviderInternal(providerId);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use setDefaultAccount(accountId).
|
|
*/
|
|
async setDefaultLegacyProvider(providerId: string): Promise<void> {
|
|
logLegacyProviderApiUsage('setDefaultLegacyProvider', 'setDefaultAccount');
|
|
return this._setDefaultProviderInternal(providerId);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use getDefaultAccountId().
|
|
*/
|
|
async getDefaultLegacyProvider(): Promise<string | undefined> {
|
|
logLegacyProviderApiUsage('getDefaultLegacyProvider', 'getDefaultAccountId');
|
|
return this._getDefaultProviderInternal();
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use secret-store APIs by accountId.
|
|
*/
|
|
async setLegacyProviderApiKey(providerId: string, apiKey: string): Promise<boolean> {
|
|
logLegacyProviderApiUsage('setLegacyProviderApiKey', 'setProviderSecret(accountId, api_key)');
|
|
return this._setProviderApiKeyInternal(providerId, apiKey);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use getAccountApiKey(accountId).
|
|
*/
|
|
async getLegacyProviderApiKey(providerId: string): Promise<string | null> {
|
|
logLegacyProviderApiUsage('getLegacyProviderApiKey', 'getAccountApiKey');
|
|
return this._getProviderApiKeyInternal(providerId);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use secret-store APIs by accountId.
|
|
*/
|
|
async deleteLegacyProviderApiKey(providerId: string): Promise<boolean> {
|
|
logLegacyProviderApiUsage('deleteLegacyProviderApiKey', 'deleteProviderSecret(accountId)');
|
|
return this._deleteProviderApiKeyInternal(providerId);
|
|
}
|
|
|
|
/**
|
|
* @deprecated Use hasAccountApiKey(accountId).
|
|
*/
|
|
async hasLegacyProviderApiKey(providerId: string): Promise<boolean> {
|
|
logLegacyProviderApiUsage('hasLegacyProviderApiKey', 'hasAccountApiKey');
|
|
return this._hasProviderApiKeyInternal(providerId);
|
|
}
|
|
|
|
async setDefaultAccount(accountId: string): Promise<void> {
|
|
await ensureProviderStoreMigrated();
|
|
await setDefaultProviderAccount(accountId);
|
|
await setDefaultProvider(accountId);
|
|
}
|
|
|
|
getVendorDefinition(vendorId: string): ProviderDefinition | undefined {
|
|
return getProviderDefinition(vendorId);
|
|
}
|
|
}
|
|
|
|
const providerService = new ProviderService();
|
|
|
|
export function getProviderService(): ProviderService {
|
|
return providerService;
|
|
}
|