1383 lines
45 KiB
TypeScript
1383 lines
45 KiB
TypeScript
import {
|
|
mkdir,
|
|
readFile,
|
|
realpath,
|
|
rename,
|
|
rm,
|
|
stat,
|
|
writeFile
|
|
} from 'node:fs/promises'
|
|
import { homedir } from 'node:os'
|
|
import { dirname } from 'node:path'
|
|
import { z } from 'zod'
|
|
import {
|
|
continueModeSchema,
|
|
defaultModelProfileId,
|
|
defaultRuntimeSettings,
|
|
imageGenerationQualitySchema,
|
|
isAgentRuntimeModelProtocol,
|
|
modelAuthenticationSchema,
|
|
modelProtocolSchema,
|
|
runtimeModelSourceSchema,
|
|
runtimePathSchema,
|
|
runtimeProviderSchema,
|
|
runtimeSandboxModeSchema,
|
|
toolApprovalPolicySchema,
|
|
RuntimeSettings,
|
|
type RuntimeSettingsInput
|
|
} from '../shared/contracts'
|
|
|
|
const credentialSchema = z
|
|
.object({
|
|
formatVersion: z.literal(1),
|
|
scheme: z.literal('electron-safe-storage'),
|
|
ciphertextBase64: z.string()
|
|
})
|
|
.optional()
|
|
|
|
const version4StoredSettingsSchema = z.object({
|
|
version: z.literal(4),
|
|
provider: runtimeProviderSchema,
|
|
modelBaseUrl: z.string(),
|
|
modelName: z.string(),
|
|
opencodeBaseUrl: z.string().default(''),
|
|
opencodeEmbedded: z.boolean().default(false),
|
|
opencodeBinaryPath: runtimePathSchema.default(''),
|
|
opencodeConfigPath: runtimePathSchema.default(''),
|
|
continueBinaryPath: runtimePathSchema.default(''),
|
|
continueConfigPath: runtimePathSchema.default(''),
|
|
continueMode: continueModeSchema.default('chat'),
|
|
workspacePath: z.string().default(''),
|
|
credential: credentialSchema,
|
|
toolApproval: toolApprovalPolicySchema
|
|
})
|
|
|
|
const version5StoredModelProfileSchema = z.object({
|
|
id: z.string().uuid(),
|
|
name: z.string(),
|
|
baseUrl: z.string(),
|
|
modelName: z.string(),
|
|
credential: credentialSchema
|
|
})
|
|
|
|
const version5StoredSettingsSchema = z.object({
|
|
version: z.literal(5),
|
|
provider: runtimeProviderSchema,
|
|
modelProfiles: z.array(version5StoredModelProfileSchema).min(1).max(20),
|
|
defaultModelProfileId: z.string().uuid(),
|
|
opencodeModelSource: runtimeModelSourceSchema,
|
|
continueModelSource: runtimeModelSourceSchema,
|
|
opencodeBaseUrl: z.string().default(''),
|
|
opencodeEmbedded: z.boolean().default(false),
|
|
opencodeBinaryPath: runtimePathSchema.default(''),
|
|
opencodeConfigPath: runtimePathSchema.default(''),
|
|
continueBinaryPath: runtimePathSchema.default(''),
|
|
continueConfigPath: runtimePathSchema.default(''),
|
|
continueMode: continueModeSchema.default('chat'),
|
|
workspacePath: z.string().default(''),
|
|
toolApproval: toolApprovalPolicySchema
|
|
})
|
|
|
|
const version6StoredModelProfileSchema =
|
|
version5StoredModelProfileSchema.extend({
|
|
protocol: modelProtocolSchema,
|
|
authentication: modelAuthenticationSchema
|
|
})
|
|
|
|
const version6StoredSettingsSchema = version5StoredSettingsSchema
|
|
.omit({ version: true, modelProfiles: true })
|
|
.extend({
|
|
version: z.literal(6),
|
|
modelProfiles: z
|
|
.array(version6StoredModelProfileSchema)
|
|
.min(1)
|
|
.max(20),
|
|
runtimeSandboxMode: runtimeSandboxModeSchema.default('auto'),
|
|
knowledgeEmbeddingEnabled: z.boolean().default(false),
|
|
knowledgeEmbeddingBaseUrl: z
|
|
.string()
|
|
.default('http://127.0.0.1:11434'),
|
|
knowledgeEmbeddingModel: z.string().default('nomic-embed-text')
|
|
})
|
|
|
|
const version7StoredSettingsSchema = version6StoredSettingsSchema
|
|
.omit({ version: true })
|
|
.extend({
|
|
version: z.literal(7),
|
|
knowledgeEmbeddingCredential: credentialSchema
|
|
})
|
|
|
|
const storedModelProfileSchema = version6StoredModelProfileSchema.extend({
|
|
imageGenerationQuality: imageGenerationQualitySchema
|
|
})
|
|
|
|
const version8StoredSettingsSchema = version7StoredSettingsSchema
|
|
.omit({ version: true, modelProfiles: true })
|
|
.extend({
|
|
version: z.literal(8),
|
|
modelProfiles: z.array(storedModelProfileSchema).min(1).max(20)
|
|
})
|
|
|
|
const version9StoredSettingsSchema = version8StoredSettingsSchema
|
|
.omit({ version: true })
|
|
.extend({
|
|
version: z.literal(9),
|
|
subagentSmartRoutingEnabled: z.boolean()
|
|
})
|
|
|
|
const version10StoredSettingsSchema = version9StoredSettingsSchema
|
|
.omit({ version: true })
|
|
.extend({
|
|
version: z.literal(10),
|
|
intranetCompatibilityEnabled: z.boolean()
|
|
})
|
|
|
|
const version11StoredSettingsSchema = version10StoredSettingsSchema
|
|
.omit({ version: true })
|
|
.extend({
|
|
version: z.literal(11)
|
|
})
|
|
|
|
const version12StoredSettingsSchema = version11StoredSettingsSchema
|
|
.omit({ version: true, intranetCompatibilityEnabled: true })
|
|
.extend({
|
|
version: z.literal(12)
|
|
})
|
|
|
|
const currentStoredModelProfileSchema = storedModelProfileSchema.extend({
|
|
supportsImageInput: z.boolean()
|
|
})
|
|
|
|
const storedSettingsSchema = version12StoredSettingsSchema
|
|
.omit({ version: true, modelProfiles: true })
|
|
.extend({
|
|
version: z.literal(13),
|
|
modelProfiles: z
|
|
.array(currentStoredModelProfileSchema)
|
|
.min(1)
|
|
.max(20)
|
|
})
|
|
|
|
class UnsupportedRuntimeSettingsVersionError extends Error {}
|
|
|
|
type StoredSettings = z.infer<typeof storedSettingsSchema>
|
|
type Version10StoredSettings = z.infer<
|
|
typeof version10StoredSettingsSchema
|
|
>
|
|
type Version11StoredSettings = z.infer<
|
|
typeof version11StoredSettingsSchema
|
|
>
|
|
type Version12StoredSettings = z.infer<
|
|
typeof version12StoredSettingsSchema
|
|
>
|
|
|
|
const version3StoredSettingsSchema = version4StoredSettingsSchema
|
|
.omit({ version: true, continueMode: true })
|
|
.extend({ version: z.literal(3) })
|
|
|
|
const version2StoredSettingsSchema = z.object({
|
|
version: z.literal(2),
|
|
provider: runtimeProviderSchema,
|
|
modelBaseUrl: z.string(),
|
|
modelName: z.string(),
|
|
opencodeBaseUrl: z.string().default(''),
|
|
opencodeEmbedded: z.boolean().default(false),
|
|
continueCommand: runtimePathSchema.default('cn'),
|
|
workspacePath: z.string().default(''),
|
|
credential: credentialSchema,
|
|
toolApproval: toolApprovalPolicySchema
|
|
})
|
|
|
|
const legacyStoredSettingsSchema = z.object({
|
|
version: z.literal(1),
|
|
provider: z.enum(['auto', 'bigtoken', 'opencode', 'continue']),
|
|
bigtokenBaseUrl: z.string(),
|
|
bigtokenModel: z.string(),
|
|
opencodeBaseUrl: z.string().default(''),
|
|
opencodeEmbedded: z.boolean().default(false),
|
|
continueCommand: runtimePathSchema.default('cn'),
|
|
workspacePath: z.string().default(''),
|
|
credential: credentialSchema,
|
|
toolApproval: toolApprovalPolicySchema
|
|
})
|
|
|
|
const credentialPayloadSchema = z.object({
|
|
version: z.literal(1),
|
|
apiKey: z.string(),
|
|
origin: z.string()
|
|
})
|
|
|
|
const embeddingCredentialPayloadSchema = z.object({
|
|
version: z.literal(1),
|
|
apiKey: z.string(),
|
|
endpoint: z.string()
|
|
})
|
|
|
|
export type CredentialCipher = {
|
|
isAvailable: () => boolean
|
|
encrypt: (value: string) => Buffer
|
|
decrypt: (value: Buffer) => string
|
|
}
|
|
|
|
export type ResolvedRuntimeSettings = {
|
|
provider: RuntimeSettings['provider']
|
|
modelBaseUrl: string
|
|
modelName: string
|
|
modelProtocol: RuntimeSettings['modelProtocol']
|
|
modelAuthentication: RuntimeSettings['modelAuthentication']
|
|
supportsImageInput?: boolean
|
|
imageGenerationQuality: RuntimeSettings['imageGenerationQuality']
|
|
apiKey?: string
|
|
modelProfiles: ResolvedModelProfile[]
|
|
defaultModelProfileId: string
|
|
opencodeModelProfile?: ResolvedModelProfile
|
|
continueModelProfile?: ResolvedModelProfile
|
|
opencodeBaseUrl: string
|
|
opencodeEmbedded: boolean
|
|
opencodeBinaryPath: string
|
|
opencodeConfigPath: string
|
|
continueBinaryPath: string
|
|
continueConfigPath: string
|
|
continueMode: RuntimeSettings['continueMode']
|
|
runtimeSandboxMode: RuntimeSettings['runtimeSandboxMode']
|
|
subagentSmartRoutingEnabled: boolean
|
|
knowledgeEmbeddingEnabled: boolean
|
|
knowledgeEmbeddingBaseUrl: string
|
|
knowledgeEmbeddingModel: string
|
|
knowledgeEmbeddingApiKey?: string
|
|
workspacePath: string
|
|
toolApproval: RuntimeSettings['toolApproval']
|
|
}
|
|
|
|
export type ResolvedModelProfile = {
|
|
id: string
|
|
name: string
|
|
baseUrl: string
|
|
modelName: string
|
|
protocol: RuntimeSettings['modelProtocol']
|
|
authentication: RuntimeSettings['modelAuthentication']
|
|
supportsImageInput?: boolean
|
|
imageGenerationQuality?: RuntimeSettings['imageGenerationQuality']
|
|
apiKey?: string
|
|
}
|
|
|
|
const defaultSettings: StoredSettings = {
|
|
version: 13,
|
|
provider: defaultRuntimeSettings.provider,
|
|
modelProfiles: [
|
|
{
|
|
id: defaultModelProfileId,
|
|
name: '默认模型',
|
|
baseUrl: defaultRuntimeSettings.modelBaseUrl,
|
|
modelName: defaultRuntimeSettings.modelName,
|
|
protocol: defaultRuntimeSettings.modelProtocol,
|
|
authentication: defaultRuntimeSettings.modelAuthentication,
|
|
supportsImageInput: defaultRuntimeSettings.supportsImageInput,
|
|
imageGenerationQuality:
|
|
defaultRuntimeSettings.imageGenerationQuality
|
|
}
|
|
],
|
|
defaultModelProfileId,
|
|
opencodeModelSource: {
|
|
kind: 'profile',
|
|
profileId: defaultModelProfileId
|
|
},
|
|
continueModelSource: {
|
|
kind: 'profile',
|
|
profileId: defaultModelProfileId
|
|
},
|
|
opencodeBaseUrl: defaultRuntimeSettings.opencodeBaseUrl,
|
|
opencodeEmbedded: defaultRuntimeSettings.opencodeEmbedded,
|
|
opencodeBinaryPath: defaultRuntimeSettings.opencodeBinaryPath,
|
|
opencodeConfigPath: defaultRuntimeSettings.opencodeConfigPath,
|
|
continueBinaryPath: defaultRuntimeSettings.continueBinaryPath,
|
|
continueConfigPath: defaultRuntimeSettings.continueConfigPath,
|
|
continueMode: defaultRuntimeSettings.continueMode,
|
|
runtimeSandboxMode: defaultRuntimeSettings.runtimeSandboxMode,
|
|
subagentSmartRoutingEnabled:
|
|
defaultRuntimeSettings.subagentSmartRoutingEnabled,
|
|
knowledgeEmbeddingEnabled:
|
|
defaultRuntimeSettings.knowledgeEmbeddingEnabled,
|
|
knowledgeEmbeddingBaseUrl:
|
|
defaultRuntimeSettings.knowledgeEmbeddingBaseUrl,
|
|
knowledgeEmbeddingModel:
|
|
defaultRuntimeSettings.knowledgeEmbeddingModel,
|
|
workspacePath: defaultRuntimeSettings.workspacePath,
|
|
toolApproval: defaultRuntimeSettings.toolApproval
|
|
}
|
|
|
|
function migrateContinueCommand(command: string): string {
|
|
const value = command.trim()
|
|
return value === 'cn' ? '' : value
|
|
}
|
|
|
|
function compatibleTextProfileId(
|
|
settings: Pick<
|
|
Version10StoredSettings,
|
|
'modelProfiles' | 'defaultModelProfileId'
|
|
>
|
|
): string | undefined {
|
|
const defaultProfile = settings.modelProfiles.find(
|
|
(profile) => profile.id === settings.defaultModelProfileId
|
|
)
|
|
if (
|
|
defaultProfile &&
|
|
defaultProfile.protocol !== 'openai-images-generations'
|
|
) {
|
|
return defaultProfile.id
|
|
}
|
|
return settings.modelProfiles.find(
|
|
(profile) => profile.protocol !== 'openai-images-generations'
|
|
)?.id
|
|
}
|
|
|
|
function migrateVersion11(
|
|
settings: Version11StoredSettings
|
|
): StoredSettings {
|
|
const {
|
|
intranetCompatibilityEnabled: _obsolete,
|
|
...current
|
|
} = settings
|
|
void _obsolete
|
|
return migrateVersion12({
|
|
...current,
|
|
version: 12
|
|
})
|
|
}
|
|
|
|
function migrateVersion12(
|
|
settings: Version12StoredSettings
|
|
): StoredSettings {
|
|
return {
|
|
...settings,
|
|
version: 13,
|
|
modelProfiles: settings.modelProfiles.map((profile) => ({
|
|
...profile,
|
|
supportsImageInput: false
|
|
}))
|
|
}
|
|
}
|
|
|
|
function migrateVersion10(
|
|
settings: Version10StoredSettings
|
|
): StoredSettings {
|
|
const profileId = compatibleTextProfileId(settings)
|
|
const preserveOpenCodePlatform =
|
|
settings.opencodeModelSource.kind === 'platform' &&
|
|
(settings.provider === 'opencode' ||
|
|
Boolean(settings.opencodeBaseUrl.trim()) ||
|
|
Boolean(settings.opencodeConfigPath.trim()))
|
|
const preserveContinuePlatform =
|
|
settings.continueModelSource.kind === 'platform' &&
|
|
(settings.provider === 'continue' ||
|
|
Boolean(settings.continueConfigPath.trim()))
|
|
|
|
return migrateVersion11({
|
|
...settings,
|
|
version: 11,
|
|
provider: settings.provider === 'auto' ? 'model' : settings.provider,
|
|
opencodeModelSource:
|
|
settings.opencodeModelSource.kind === 'profile' ||
|
|
preserveOpenCodePlatform ||
|
|
!profileId
|
|
? settings.opencodeModelSource
|
|
: { kind: 'profile', profileId },
|
|
continueModelSource:
|
|
settings.continueModelSource.kind === 'profile' ||
|
|
preserveContinuePlatform ||
|
|
!profileId
|
|
? settings.continueModelSource
|
|
: { kind: 'profile', profileId },
|
|
opencodeEmbedded: !settings.opencodeBaseUrl.trim()
|
|
})
|
|
}
|
|
|
|
function normalizeStoredSettings(settings: StoredSettings): StoredSettings {
|
|
const fallbackProfileId = compatibleTextProfileId(settings)
|
|
const normalizeSource = (
|
|
source: RuntimeSettings['opencodeModelSource']
|
|
): RuntimeSettings['opencodeModelSource'] => {
|
|
if (source.kind === 'platform') {
|
|
return source
|
|
}
|
|
const profile = settings.modelProfiles.find(
|
|
(candidate) => candidate.id === source.profileId
|
|
)
|
|
if (profile && isAgentRuntimeModelProtocol(profile.protocol)) {
|
|
return source
|
|
}
|
|
return fallbackProfileId
|
|
? { kind: 'profile', profileId: fallbackProfileId }
|
|
: { kind: 'platform' }
|
|
}
|
|
const opencodeBaseUrl = settings.opencodeBaseUrl.trim()
|
|
const defaultModelProfileId = settings.modelProfiles.some(
|
|
(profile) => profile.id === settings.defaultModelProfileId
|
|
)
|
|
? settings.defaultModelProfileId
|
|
: settings.modelProfiles[0]!.id
|
|
|
|
return {
|
|
...settings,
|
|
provider:
|
|
settings.provider === 'auto' ? 'model' : settings.provider,
|
|
defaultModelProfileId,
|
|
opencodeModelSource: opencodeBaseUrl
|
|
? { kind: 'platform' }
|
|
: normalizeSource(settings.opencodeModelSource),
|
|
continueModelSource: normalizeSource(
|
|
settings.continueModelSource
|
|
),
|
|
opencodeBaseUrl,
|
|
opencodeEmbedded: !opencodeBaseUrl
|
|
}
|
|
}
|
|
|
|
function migrateVersion4(
|
|
settings: z.infer<typeof version4StoredSettingsSchema>
|
|
): StoredSettings {
|
|
return migrateVersion10({
|
|
version: 10,
|
|
provider: settings.provider,
|
|
modelProfiles: [
|
|
{
|
|
id: defaultModelProfileId,
|
|
name: '默认模型',
|
|
baseUrl: settings.modelBaseUrl,
|
|
modelName: settings.modelName,
|
|
protocol: 'anthropic-messages',
|
|
authentication: 'api-key',
|
|
imageGenerationQuality:
|
|
defaultRuntimeSettings.imageGenerationQuality,
|
|
credential: settings.credential
|
|
}
|
|
],
|
|
defaultModelProfileId,
|
|
opencodeModelSource: { kind: 'platform' },
|
|
continueModelSource: { kind: 'platform' },
|
|
opencodeBaseUrl: settings.opencodeBaseUrl,
|
|
opencodeEmbedded: settings.opencodeEmbedded,
|
|
opencodeBinaryPath: settings.opencodeBinaryPath,
|
|
opencodeConfigPath: settings.opencodeConfigPath,
|
|
continueBinaryPath: settings.continueBinaryPath,
|
|
continueConfigPath: settings.continueConfigPath,
|
|
continueMode: settings.continueMode,
|
|
runtimeSandboxMode: defaultRuntimeSettings.runtimeSandboxMode,
|
|
subagentSmartRoutingEnabled:
|
|
defaultRuntimeSettings.subagentSmartRoutingEnabled,
|
|
intranetCompatibilityEnabled: true,
|
|
knowledgeEmbeddingEnabled:
|
|
defaultRuntimeSettings.knowledgeEmbeddingEnabled,
|
|
knowledgeEmbeddingBaseUrl:
|
|
defaultRuntimeSettings.knowledgeEmbeddingBaseUrl,
|
|
knowledgeEmbeddingModel:
|
|
defaultRuntimeSettings.knowledgeEmbeddingModel,
|
|
workspacePath: settings.workspacePath,
|
|
toolApproval: settings.toolApproval
|
|
})
|
|
}
|
|
|
|
function migrateVersion5(
|
|
settings: z.infer<typeof version5StoredSettingsSchema>
|
|
): StoredSettings {
|
|
return migrateVersion10({
|
|
...settings,
|
|
version: 10,
|
|
runtimeSandboxMode: defaultRuntimeSettings.runtimeSandboxMode,
|
|
subagentSmartRoutingEnabled:
|
|
defaultRuntimeSettings.subagentSmartRoutingEnabled,
|
|
intranetCompatibilityEnabled: true,
|
|
knowledgeEmbeddingEnabled:
|
|
defaultRuntimeSettings.knowledgeEmbeddingEnabled,
|
|
knowledgeEmbeddingBaseUrl:
|
|
defaultRuntimeSettings.knowledgeEmbeddingBaseUrl,
|
|
knowledgeEmbeddingModel:
|
|
defaultRuntimeSettings.knowledgeEmbeddingModel,
|
|
modelProfiles: settings.modelProfiles.map((profile) => ({
|
|
...profile,
|
|
protocol: 'anthropic-messages',
|
|
authentication: 'api-key',
|
|
imageGenerationQuality:
|
|
defaultRuntimeSettings.imageGenerationQuality
|
|
}))
|
|
})
|
|
}
|
|
|
|
function migrateVersion6(
|
|
settings: z.infer<typeof version6StoredSettingsSchema>
|
|
): StoredSettings {
|
|
const endpoint = new URL(settings.knowledgeEmbeddingBaseUrl)
|
|
endpoint.pathname = `${endpoint.pathname.replace(/\/+$/u, '')}/v1/embeddings`
|
|
return migrateVersion10({
|
|
...settings,
|
|
version: 10,
|
|
subagentSmartRoutingEnabled:
|
|
defaultRuntimeSettings.subagentSmartRoutingEnabled,
|
|
intranetCompatibilityEnabled: true,
|
|
knowledgeEmbeddingBaseUrl: endpoint.toString(),
|
|
modelProfiles: settings.modelProfiles.map((profile) => ({
|
|
...profile,
|
|
imageGenerationQuality:
|
|
defaultRuntimeSettings.imageGenerationQuality
|
|
}))
|
|
})
|
|
}
|
|
|
|
function migrateVersion7(
|
|
settings: z.infer<typeof version7StoredSettingsSchema>
|
|
): StoredSettings {
|
|
return migrateVersion10({
|
|
...settings,
|
|
version: 10,
|
|
subagentSmartRoutingEnabled:
|
|
defaultRuntimeSettings.subagentSmartRoutingEnabled,
|
|
intranetCompatibilityEnabled: true,
|
|
modelProfiles: settings.modelProfiles.map((profile) => ({
|
|
...profile,
|
|
imageGenerationQuality:
|
|
defaultRuntimeSettings.imageGenerationQuality
|
|
}))
|
|
})
|
|
}
|
|
|
|
function migrateVersion8(
|
|
settings: z.infer<typeof version8StoredSettingsSchema>
|
|
): StoredSettings {
|
|
return migrateVersion10({
|
|
...settings,
|
|
version: 10,
|
|
subagentSmartRoutingEnabled: false,
|
|
intranetCompatibilityEnabled: true
|
|
})
|
|
}
|
|
|
|
function migrateVersion9(
|
|
settings: z.infer<typeof version9StoredSettingsSchema>
|
|
): StoredSettings {
|
|
return migrateVersion10({
|
|
...settings,
|
|
version: 10,
|
|
intranetCompatibilityEnabled: true
|
|
})
|
|
}
|
|
|
|
function normalizeModelBaseUrl(value: string): string {
|
|
const url = new URL(value)
|
|
url.pathname = url.pathname.replace(/\/+$/u, '')
|
|
return url.toString().replace(/\/$/u, '')
|
|
}
|
|
|
|
export class RuntimeSettingsStore {
|
|
private settings?: StoredSettings
|
|
private loadWarning?: string
|
|
private updateQueue: Promise<void> = Promise.resolve()
|
|
|
|
constructor(
|
|
private readonly filePath: string,
|
|
private readonly cipher: CredentialCipher,
|
|
private readonly environment: NodeJS.ProcessEnv = process.env
|
|
) {}
|
|
|
|
private async load(): Promise<StoredSettings> {
|
|
if (this.settings) {
|
|
return this.settings
|
|
}
|
|
|
|
try {
|
|
const contents = await readFile(this.filePath, 'utf8')
|
|
const parsed: unknown = JSON.parse(contents)
|
|
if (
|
|
parsed &&
|
|
typeof parsed === 'object' &&
|
|
'version' in parsed &&
|
|
typeof parsed.version === 'number' &&
|
|
parsed.version > 13
|
|
) {
|
|
throw new UnsupportedRuntimeSettingsVersionError(
|
|
`当前 GoodBuddy 不支持 Runtime 设置版本 ${parsed.version}，请升级应用后重试`
|
|
)
|
|
}
|
|
const current = storedSettingsSchema.safeParse(parsed)
|
|
if (current.success) {
|
|
this.settings = current.data
|
|
} else {
|
|
const version12 =
|
|
version12StoredSettingsSchema.safeParse(parsed)
|
|
if (version12.success) {
|
|
this.settings = migrateVersion12(version12.data)
|
|
} else {
|
|
const version11 =
|
|
version11StoredSettingsSchema.safeParse(parsed)
|
|
if (version11.success) {
|
|
this.settings = migrateVersion11(version11.data)
|
|
} else {
|
|
const version10 =
|
|
version10StoredSettingsSchema.safeParse(parsed)
|
|
if (version10.success) {
|
|
this.settings = migrateVersion10(version10.data)
|
|
} else {
|
|
const version9 =
|
|
version9StoredSettingsSchema.safeParse(parsed)
|
|
if (version9.success) {
|
|
this.settings = migrateVersion9(version9.data)
|
|
} else {
|
|
const version8 =
|
|
version8StoredSettingsSchema.safeParse(parsed)
|
|
if (version8.success) {
|
|
this.settings = migrateVersion8(version8.data)
|
|
} else {
|
|
const version7 =
|
|
version7StoredSettingsSchema.safeParse(parsed)
|
|
if (version7.success) {
|
|
this.settings = migrateVersion7(version7.data)
|
|
} else {
|
|
const version6 =
|
|
version6StoredSettingsSchema.safeParse(parsed)
|
|
if (version6.success) {
|
|
this.settings = migrateVersion6(version6.data)
|
|
} else {
|
|
const version5 =
|
|
version5StoredSettingsSchema.safeParse(parsed)
|
|
if (version5.success) {
|
|
this.settings = migrateVersion5(version5.data)
|
|
} else {
|
|
const version4 =
|
|
version4StoredSettingsSchema.safeParse(parsed)
|
|
if (version4.success) {
|
|
this.settings = migrateVersion4(version4.data)
|
|
} else {
|
|
const version3 =
|
|
version3StoredSettingsSchema.safeParse(parsed)
|
|
if (version3.success) {
|
|
this.settings = migrateVersion4({
|
|
...version3.data,
|
|
version: 4,
|
|
continueMode: 'chat'
|
|
})
|
|
} else {
|
|
const version2 =
|
|
version2StoredSettingsSchema.safeParse(parsed)
|
|
if (version2.success) {
|
|
this.settings = migrateVersion4({
|
|
version: 4,
|
|
provider: version2.data.provider,
|
|
modelBaseUrl: version2.data.modelBaseUrl,
|
|
modelName: version2.data.modelName,
|
|
opencodeBaseUrl: version2.data.opencodeBaseUrl,
|
|
opencodeEmbedded: version2.data.opencodeEmbedded,
|
|
opencodeBinaryPath: '',
|
|
opencodeConfigPath: '',
|
|
continueBinaryPath: migrateContinueCommand(
|
|
version2.data.continueCommand
|
|
),
|
|
continueConfigPath: '',
|
|
continueMode: 'chat',
|
|
workspacePath: version2.data.workspacePath,
|
|
credential: version2.data.credential,
|
|
toolApproval: version2.data.toolApproval
|
|
})
|
|
} else {
|
|
const legacy =
|
|
legacyStoredSettingsSchema.parse(parsed)
|
|
this.settings = migrateVersion4({
|
|
version: 4,
|
|
provider:
|
|
legacy.provider === 'bigtoken'
|
|
? 'model'
|
|
: legacy.provider,
|
|
modelBaseUrl: legacy.bigtokenBaseUrl,
|
|
modelName: legacy.bigtokenModel,
|
|
opencodeBaseUrl: legacy.opencodeBaseUrl,
|
|
opencodeEmbedded: legacy.opencodeEmbedded,
|
|
opencodeBinaryPath: '',
|
|
opencodeConfigPath: '',
|
|
continueBinaryPath: migrateContinueCommand(
|
|
legacy.continueCommand
|
|
),
|
|
continueConfigPath: '',
|
|
continueMode: 'chat',
|
|
workspacePath: legacy.workspacePath,
|
|
credential: legacy.credential,
|
|
toolApproval: legacy.toolApproval
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.settings = normalizeStoredSettings(this.settings)
|
|
} catch (error) {
|
|
if (error instanceof UnsupportedRuntimeSettingsVersionError) {
|
|
throw error
|
|
}
|
|
if (
|
|
!(
|
|
error &&
|
|
typeof error === 'object' &&
|
|
'code' in error &&
|
|
error.code === 'ENOENT'
|
|
)
|
|
) {
|
|
this.loadWarning =
|
|
'Runtime 设置文件已损坏，已隔离原文件并恢复默认设置'
|
|
await rename(
|
|
this.filePath,
|
|
`${this.filePath}.corrupt-${Date.now()}`
|
|
).catch(() => undefined)
|
|
}
|
|
this.settings = { ...defaultSettings }
|
|
}
|
|
return this.settings
|
|
}
|
|
|
|
private getStoredApiKey(
|
|
profile: StoredSettings['modelProfiles'][number]
|
|
): string | undefined {
|
|
if (!profile.credential || !this.cipher.isAvailable()) {
|
|
return undefined
|
|
}
|
|
try {
|
|
const payload = credentialPayloadSchema.parse(
|
|
JSON.parse(
|
|
this.cipher.decrypt(
|
|
Buffer.from(profile.credential.ciphertextBase64, 'base64')
|
|
)
|
|
)
|
|
)
|
|
if (payload.origin !== new URL(profile.baseUrl).origin) {
|
|
this.loadWarning =
|
|
`模型连接“${profile.name}”的服务地址与已保存 API Key 不匹配，请重新输入或清除 API Key`
|
|
return undefined
|
|
}
|
|
return payload.apiKey
|
|
} catch {
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
private getStoredEmbeddingApiKey(
|
|
settings: StoredSettings
|
|
): string | undefined {
|
|
if (
|
|
!settings.knowledgeEmbeddingCredential ||
|
|
!this.cipher.isAvailable()
|
|
) {
|
|
return undefined
|
|
}
|
|
try {
|
|
const payload = embeddingCredentialPayloadSchema.parse(
|
|
JSON.parse(
|
|
this.cipher.decrypt(
|
|
Buffer.from(
|
|
settings.knowledgeEmbeddingCredential.ciphertextBase64,
|
|
'base64'
|
|
)
|
|
)
|
|
)
|
|
)
|
|
return payload.endpoint === settings.knowledgeEmbeddingBaseUrl
|
|
? payload.apiKey
|
|
: undefined
|
|
} catch {
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
private getEnvironmentApiKey(): string | undefined {
|
|
return (
|
|
this.environment.GOODBUDDY_MODEL_API_KEY?.trim() ||
|
|
this.environment.GOODBUDDY_BIGTOKEN_API_KEY?.trim() ||
|
|
undefined
|
|
)
|
|
}
|
|
|
|
private resolveEffectiveModelSettings(settings: StoredSettings): {
|
|
apiKey?: string
|
|
baseUrl: string
|
|
model: string
|
|
protocol: RuntimeSettings['modelProtocol']
|
|
authentication: RuntimeSettings['modelAuthentication']
|
|
supportsImageInput: boolean
|
|
imageGenerationQuality: RuntimeSettings['imageGenerationQuality']
|
|
credentialSource: RuntimeSettings['credentialSource']
|
|
} {
|
|
const profile =
|
|
settings.modelProfiles.find(
|
|
(candidate) => candidate.id === settings.defaultModelProfileId
|
|
) ?? settings.modelProfiles[0]
|
|
if (!profile) {
|
|
throw new Error('默认模型连接不存在')
|
|
}
|
|
const environmentApiKey =
|
|
profile.authentication === 'api-key'
|
|
? this.getEnvironmentApiKey()
|
|
: undefined
|
|
const storedApiKey =
|
|
profile.authentication === 'api-key'
|
|
? this.getStoredApiKey(profile)
|
|
: undefined
|
|
const environmentBaseUrl =
|
|
this.environment.GOODBUDDY_MODEL_BASE_URL?.trim() ||
|
|
this.environment.GOODBUDDY_BIGTOKEN_BASE_URL?.trim()
|
|
const environmentModel =
|
|
this.environment.GOODBUDDY_MODEL_NAME?.trim() ||
|
|
this.environment.GOODBUDDY_BIGTOKEN_MODEL?.trim()
|
|
const baseUrl = environmentApiKey
|
|
? environmentBaseUrl || defaultRuntimeSettings.modelBaseUrl
|
|
: profile.baseUrl
|
|
const model = environmentApiKey
|
|
? environmentModel || defaultRuntimeSettings.modelName
|
|
: profile.modelName
|
|
return {
|
|
apiKey: environmentApiKey ?? storedApiKey,
|
|
baseUrl,
|
|
model,
|
|
protocol: profile.protocol,
|
|
authentication: profile.authentication,
|
|
supportsImageInput: profile.supportsImageInput,
|
|
imageGenerationQuality: profile.imageGenerationQuality,
|
|
credentialSource: environmentApiKey
|
|
? 'environment'
|
|
: storedApiKey
|
|
? 'encrypted'
|
|
: 'none'
|
|
}
|
|
}
|
|
|
|
private resolveProfile(
|
|
settings: StoredSettings,
|
|
profileId: string
|
|
): ResolvedModelProfile | undefined {
|
|
const profile = settings.modelProfiles.find(
|
|
(candidate) => candidate.id === profileId
|
|
)
|
|
if (!profile) {
|
|
return undefined
|
|
}
|
|
if (profile.id === settings.defaultModelProfileId) {
|
|
const effective = this.resolveEffectiveModelSettings(settings)
|
|
return {
|
|
id: profile.id,
|
|
name: profile.name,
|
|
baseUrl: effective.baseUrl,
|
|
modelName: effective.model,
|
|
protocol: effective.protocol,
|
|
authentication: effective.authentication,
|
|
supportsImageInput: effective.supportsImageInput,
|
|
imageGenerationQuality: effective.imageGenerationQuality,
|
|
apiKey: effective.apiKey
|
|
}
|
|
}
|
|
return {
|
|
id: profile.id,
|
|
name: profile.name,
|
|
baseUrl: profile.baseUrl,
|
|
modelName: profile.modelName,
|
|
protocol: profile.protocol,
|
|
authentication: profile.authentication,
|
|
supportsImageInput: profile.supportsImageInput,
|
|
imageGenerationQuality: profile.imageGenerationQuality,
|
|
apiKey:
|
|
profile.authentication === 'api-key'
|
|
? this.getStoredApiKey(profile)
|
|
: undefined
|
|
}
|
|
}
|
|
|
|
private resolveAgentSettings(settings: StoredSettings): {
|
|
opencodeBaseUrl: string
|
|
opencodeEmbedded: boolean
|
|
opencodeBinaryPath: string
|
|
opencodeConfigPath: string
|
|
continueBinaryPath: string
|
|
continueConfigPath: string
|
|
continueMode: RuntimeSettings['continueMode']
|
|
runtimeSandboxMode: RuntimeSettings['runtimeSandboxMode']
|
|
workspacePath: string
|
|
} {
|
|
const continueBinaryEnvironment =
|
|
this.environment.GOODBUDDY_CONTINUE_BINARY?.trim()
|
|
const legacyContinueCommand =
|
|
this.environment.GOODBUDDY_CONTINUE_COMMAND?.trim()
|
|
const opencodeBaseUrl =
|
|
this.environment.GOODBUDDY_OPENCODE_URL?.trim() ??
|
|
settings.opencodeBaseUrl
|
|
return {
|
|
opencodeBaseUrl,
|
|
opencodeEmbedded: !opencodeBaseUrl,
|
|
opencodeBinaryPath:
|
|
this.environment.GOODBUDDY_OPENCODE_BINARY?.trim() ||
|
|
settings.opencodeBinaryPath,
|
|
opencodeConfigPath:
|
|
this.environment.GOODBUDDY_OPENCODE_CONFIG?.trim() ||
|
|
settings.opencodeConfigPath,
|
|
continueBinaryPath:
|
|
continueBinaryEnvironment ||
|
|
(legacyContinueCommand
|
|
? migrateContinueCommand(legacyContinueCommand)
|
|
: '') ||
|
|
settings.continueBinaryPath,
|
|
continueConfigPath:
|
|
this.environment.GOODBUDDY_CONTINUE_CONFIG?.trim() ||
|
|
settings.continueConfigPath,
|
|
continueMode: settings.continueMode,
|
|
runtimeSandboxMode: settings.runtimeSandboxMode,
|
|
workspacePath:
|
|
this.environment.GOODBUDDY_WORKSPACE?.trim() ||
|
|
settings.workspacePath ||
|
|
homedir()
|
|
}
|
|
}
|
|
|
|
private toPublicSettings(settings: StoredSettings): RuntimeSettings {
|
|
const effective = this.resolveEffectiveModelSettings(settings)
|
|
const agent = this.resolveAgentSettings(settings)
|
|
const modelProfiles = settings.modelProfiles.map((profile) => {
|
|
const isDefault = profile.id === settings.defaultModelProfileId
|
|
const apiKey =
|
|
profile.authentication === 'api-key'
|
|
? this.getStoredApiKey(profile)
|
|
: undefined
|
|
return {
|
|
id: profile.id,
|
|
name: profile.name,
|
|
baseUrl: isDefault
|
|
? effective.baseUrl
|
|
: profile.baseUrl,
|
|
modelName: isDefault ? effective.model : profile.modelName,
|
|
protocol: isDefault
|
|
? effective.protocol
|
|
: profile.protocol,
|
|
authentication: isDefault
|
|
? effective.authentication
|
|
: profile.authentication,
|
|
supportsImageInput: isDefault
|
|
? effective.supportsImageInput
|
|
: profile.supportsImageInput,
|
|
imageGenerationQuality: isDefault
|
|
? effective.imageGenerationQuality
|
|
: profile.imageGenerationQuality,
|
|
apiKeyConfigured: isDefault
|
|
? Boolean(effective.apiKey)
|
|
: Boolean(apiKey),
|
|
credentialSource: isDefault
|
|
? effective.credentialSource
|
|
: apiKey
|
|
? ('encrypted' as const)
|
|
: ('none' as const)
|
|
}
|
|
})
|
|
const embeddingEnvironmentApiKey =
|
|
this.environment.GOODBUDDY_EMBEDDING_API_KEY?.trim()
|
|
const embeddingStoredApiKey =
|
|
this.getStoredEmbeddingApiKey(settings)
|
|
return {
|
|
provider: settings.provider,
|
|
modelBaseUrl: effective.baseUrl,
|
|
modelName: effective.model,
|
|
modelProtocol: effective.protocol,
|
|
modelAuthentication: effective.authentication,
|
|
supportsImageInput: effective.supportsImageInput,
|
|
imageGenerationQuality: effective.imageGenerationQuality,
|
|
opencodeBaseUrl: agent.opencodeBaseUrl,
|
|
opencodeEmbedded: agent.opencodeEmbedded,
|
|
opencodeBinaryPath: agent.opencodeBinaryPath,
|
|
opencodeConfigPath: agent.opencodeConfigPath,
|
|
continueBinaryPath: agent.continueBinaryPath,
|
|
continueConfigPath: agent.continueConfigPath,
|
|
continueMode: agent.continueMode,
|
|
runtimeSandboxMode: agent.runtimeSandboxMode,
|
|
subagentSmartRoutingEnabled:
|
|
settings.subagentSmartRoutingEnabled,
|
|
knowledgeEmbeddingEnabled: settings.knowledgeEmbeddingEnabled,
|
|
knowledgeEmbeddingBaseUrl: settings.knowledgeEmbeddingBaseUrl,
|
|
knowledgeEmbeddingModel: settings.knowledgeEmbeddingModel,
|
|
knowledgeEmbeddingApiKeyConfigured: Boolean(
|
|
embeddingEnvironmentApiKey ?? embeddingStoredApiKey
|
|
),
|
|
knowledgeEmbeddingCredentialSource: embeddingEnvironmentApiKey
|
|
? 'environment'
|
|
: embeddingStoredApiKey
|
|
? 'encrypted'
|
|
: 'none',
|
|
workspacePath: agent.workspacePath,
|
|
apiKeyConfigured: Boolean(effective.apiKey),
|
|
credentialSource: effective.credentialSource,
|
|
modelProfiles,
|
|
defaultModelProfileId: settings.defaultModelProfileId,
|
|
opencodeModelSource: agent.opencodeBaseUrl
|
|
? { kind: 'platform' }
|
|
: settings.opencodeModelSource,
|
|
continueModelSource: settings.continueModelSource,
|
|
secureStorageAvailable: this.cipher.isAvailable(),
|
|
toolApproval: settings.toolApproval,
|
|
warning: this.loadWarning
|
|
}
|
|
}
|
|
|
|
async getPublicSettings(): Promise<RuntimeSettings> {
|
|
return this.toPublicSettings(await this.load())
|
|
}
|
|
|
|
async getResolvedSettings(): Promise<ResolvedRuntimeSettings> {
|
|
const settings = await this.load()
|
|
const effective = this.resolveEffectiveModelSettings(settings)
|
|
const agent = this.resolveAgentSettings(settings)
|
|
const opencodeModelProfile =
|
|
!agent.opencodeBaseUrl &&
|
|
settings.opencodeModelSource.kind === 'profile'
|
|
? this.resolveProfile(
|
|
settings,
|
|
settings.opencodeModelSource.profileId
|
|
)
|
|
: undefined
|
|
const continueModelProfile =
|
|
settings.continueModelSource.kind === 'profile'
|
|
? this.resolveProfile(
|
|
settings,
|
|
settings.continueModelSource.profileId
|
|
)
|
|
: undefined
|
|
return {
|
|
provider: settings.provider,
|
|
modelBaseUrl: effective.baseUrl,
|
|
modelName: effective.model,
|
|
modelProtocol: effective.protocol,
|
|
modelAuthentication: effective.authentication,
|
|
supportsImageInput: effective.supportsImageInput,
|
|
imageGenerationQuality: effective.imageGenerationQuality,
|
|
apiKey: effective.apiKey,
|
|
modelProfiles: settings.modelProfiles.map((profile) => {
|
|
const resolved = this.resolveProfile(settings, profile.id)
|
|
if (!resolved) {
|
|
throw new Error(`模型连接不存在：${profile.id}`)
|
|
}
|
|
return resolved
|
|
}),
|
|
defaultModelProfileId: settings.defaultModelProfileId,
|
|
opencodeModelProfile,
|
|
continueModelProfile,
|
|
...agent,
|
|
subagentSmartRoutingEnabled:
|
|
settings.subagentSmartRoutingEnabled,
|
|
knowledgeEmbeddingEnabled: settings.knowledgeEmbeddingEnabled,
|
|
knowledgeEmbeddingBaseUrl: settings.knowledgeEmbeddingBaseUrl,
|
|
knowledgeEmbeddingModel: settings.knowledgeEmbeddingModel,
|
|
knowledgeEmbeddingApiKey:
|
|
this.environment.GOODBUDDY_EMBEDDING_API_KEY?.trim() ||
|
|
this.getStoredEmbeddingApiKey(settings),
|
|
toolApproval: settings.toolApproval
|
|
}
|
|
}
|
|
|
|
update(input: RuntimeSettingsInput): Promise<RuntimeSettings> {
|
|
const operation = this.updateQueue.then(() => this.performUpdate(input))
|
|
this.updateQueue = operation.then(
|
|
() => undefined,
|
|
() => undefined
|
|
)
|
|
return operation
|
|
}
|
|
|
|
private async performUpdate(
|
|
input: RuntimeSettingsInput
|
|
): Promise<RuntimeSettings> {
|
|
const current = await this.load()
|
|
const currentDefault =
|
|
current.modelProfiles.find(
|
|
(profile) => profile.id === current.defaultModelProfileId
|
|
) ?? current.modelProfiles[0]
|
|
if (!currentDefault) {
|
|
throw new Error('默认模型连接不存在')
|
|
}
|
|
const profileInputs =
|
|
input.modelProfiles ??
|
|
current.modelProfiles.map((profile) =>
|
|
profile.id === currentDefault.id
|
|
? {
|
|
id: profile.id,
|
|
name: profile.name,
|
|
baseUrl: input.modelBaseUrl,
|
|
modelName: input.modelName,
|
|
protocol: input.modelProtocol,
|
|
authentication: input.modelAuthentication,
|
|
supportsImageInput: profile.supportsImageInput,
|
|
imageGenerationQuality: input.imageGenerationQuality,
|
|
apiKey: input.apiKey
|
|
}
|
|
: {
|
|
id: profile.id,
|
|
name: profile.name,
|
|
baseUrl: profile.baseUrl,
|
|
modelName: profile.modelName,
|
|
protocol: profile.protocol,
|
|
authentication: profile.authentication,
|
|
supportsImageInput: profile.supportsImageInput,
|
|
imageGenerationQuality: profile.imageGenerationQuality,
|
|
apiKey: { action: 'keep' as const }
|
|
}
|
|
)
|
|
if (
|
|
(
|
|
profileInputs.some(
|
|
(profile) =>
|
|
profile.authentication === 'api-key' &&
|
|
profile.apiKey.action === 'replace'
|
|
) ||
|
|
input.knowledgeEmbeddingApiKey?.action === 'replace'
|
|
) &&
|
|
!this.cipher.isAvailable()
|
|
) {
|
|
throw new Error(
|
|
'当前系统安全存储不可用，API Key 未保存。请启用系统密钥服务或使用环境变量。'
|
|
)
|
|
}
|
|
const modelProfiles: StoredSettings['modelProfiles'] =
|
|
profileInputs.map((profile) => {
|
|
const existing = current.modelProfiles.find(
|
|
(candidate) => candidate.id === profile.id
|
|
)
|
|
const normalizedBaseUrl = normalizeModelBaseUrl(profile.baseUrl)
|
|
if (
|
|
profile.authentication === 'api-key' &&
|
|
profile.apiKey.action === 'keep' &&
|
|
existing?.credential &&
|
|
new URL(existing.baseUrl).origin !==
|
|
new URL(normalizedBaseUrl).origin
|
|
) {
|
|
throw new Error(
|
|
`模型连接“${profile.name}”的服务地址已更改，请重新输入或清除 API Key`
|
|
)
|
|
}
|
|
const nextProfile: StoredSettings['modelProfiles'][number] = {
|
|
id: profile.id,
|
|
name: profile.name,
|
|
baseUrl: normalizedBaseUrl,
|
|
modelName: profile.modelName,
|
|
protocol: profile.protocol,
|
|
authentication: profile.authentication,
|
|
supportsImageInput: profile.supportsImageInput ?? false,
|
|
imageGenerationQuality: profile.imageGenerationQuality
|
|
}
|
|
if (
|
|
profile.authentication === 'api-key' &&
|
|
profile.apiKey.action === 'keep' &&
|
|
existing?.credential
|
|
) {
|
|
nextProfile.credential = existing.credential
|
|
} else if (
|
|
profile.authentication === 'api-key' &&
|
|
profile.apiKey.action === 'replace'
|
|
) {
|
|
nextProfile.credential = {
|
|
formatVersion: 1,
|
|
scheme: 'electron-safe-storage',
|
|
ciphertextBase64: this.cipher
|
|
.encrypt(
|
|
JSON.stringify({
|
|
version: 1,
|
|
apiKey: profile.apiKey.value,
|
|
origin: new URL(normalizedBaseUrl).origin
|
|
})
|
|
)
|
|
.toString('base64')
|
|
}
|
|
}
|
|
return nextProfile
|
|
})
|
|
|
|
const embeddingEndpoint = new URL(
|
|
input.knowledgeEmbeddingBaseUrl
|
|
).toString()
|
|
const embeddingApiKeyUpdate =
|
|
input.knowledgeEmbeddingApiKey ?? { action: 'keep' as const }
|
|
if (
|
|
embeddingApiKeyUpdate.action === 'keep' &&
|
|
current.knowledgeEmbeddingCredential &&
|
|
current.knowledgeEmbeddingBaseUrl !== embeddingEndpoint
|
|
) {
|
|
throw new Error(
|
|
'向量接口 URL 已更改，请重新输入或清除 API Key'
|
|
)
|
|
}
|
|
let knowledgeEmbeddingCredential: StoredSettings['knowledgeEmbeddingCredential']
|
|
if (
|
|
embeddingApiKeyUpdate.action === 'keep' &&
|
|
current.knowledgeEmbeddingCredential
|
|
) {
|
|
knowledgeEmbeddingCredential =
|
|
current.knowledgeEmbeddingCredential
|
|
} else if (embeddingApiKeyUpdate.action === 'replace') {
|
|
knowledgeEmbeddingCredential = {
|
|
formatVersion: 1,
|
|
scheme: 'electron-safe-storage',
|
|
ciphertextBase64: this.cipher
|
|
.encrypt(
|
|
JSON.stringify({
|
|
version: 1,
|
|
apiKey: embeddingApiKeyUpdate.value,
|
|
endpoint: embeddingEndpoint
|
|
})
|
|
)
|
|
.toString('base64')
|
|
}
|
|
}
|
|
|
|
const [
|
|
opencodeBinaryPath,
|
|
opencodeConfigPath,
|
|
continueBinaryPath,
|
|
continueConfigPath
|
|
] = await Promise.all([
|
|
this.canonicalizeRuntimeFile(
|
|
input.opencodeBinaryPath,
|
|
'OpenCode 可执行文件'
|
|
),
|
|
this.canonicalizeRuntimeFile(
|
|
input.opencodeConfigPath,
|
|
'OpenCode 配置文件'
|
|
),
|
|
this.canonicalizeRuntimeFile(
|
|
input.continueBinaryPath,
|
|
'Continue 可执行文件'
|
|
),
|
|
this.canonicalizeRuntimeFile(
|
|
input.continueConfigPath,
|
|
'Continue 配置文件'
|
|
)
|
|
])
|
|
|
|
const defaultModelProfileId =
|
|
input.defaultModelProfileId ??
|
|
(input.modelProfiles
|
|
? modelProfiles[0]!.id
|
|
: current.defaultModelProfileId)
|
|
if (
|
|
!modelProfiles.some(
|
|
(profile) => profile.id === defaultModelProfileId
|
|
)
|
|
) {
|
|
throw new Error('默认模型连接不存在')
|
|
}
|
|
const validateRuntimeSource = (
|
|
source: RuntimeSettings['opencodeModelSource'],
|
|
runtimeLabel: 'OpenCode' | 'Continue'
|
|
): void => {
|
|
if (source.kind === 'platform') {
|
|
return
|
|
}
|
|
const profile = modelProfiles.find(
|
|
(candidate) => candidate.id === source.profileId
|
|
)
|
|
if (!profile) {
|
|
throw new Error(`${runtimeLabel} 引用的模型连接不存在`)
|
|
}
|
|
if (!isAgentRuntimeModelProtocol(profile.protocol)) {
|
|
throw new Error(
|
|
`${runtimeLabel} 模型连接仅支持文本对话协议，不支持图像生成协议`
|
|
)
|
|
}
|
|
}
|
|
const opencodeBaseUrl = input.opencodeBaseUrl
|
|
? normalizeModelBaseUrl(input.opencodeBaseUrl)
|
|
: ''
|
|
const fallbackRuntimeProfileId = modelProfiles.find(
|
|
(profile) => isAgentRuntimeModelProtocol(profile.protocol)
|
|
)?.id
|
|
const repairRuntimeSource = (
|
|
source: RuntimeSettings['opencodeModelSource']
|
|
): RuntimeSettings['opencodeModelSource'] => {
|
|
if (source.kind === 'platform') {
|
|
return source
|
|
}
|
|
const profile = modelProfiles.find(
|
|
(candidate) => candidate.id === source.profileId
|
|
)
|
|
if (profile && isAgentRuntimeModelProtocol(profile.protocol)) {
|
|
return source
|
|
}
|
|
return fallbackRuntimeProfileId
|
|
? { kind: 'profile', profileId: fallbackRuntimeProfileId }
|
|
: { kind: 'platform' }
|
|
}
|
|
const requestedOpenCodeSource = input.opencodeModelSource
|
|
? input.opencodeModelSource
|
|
: repairRuntimeSource(current.opencodeModelSource)
|
|
const opencodeModelSource = opencodeBaseUrl
|
|
? ({ kind: 'platform' } as const)
|
|
: requestedOpenCodeSource
|
|
const continueModelSource = input.continueModelSource
|
|
? input.continueModelSource
|
|
: repairRuntimeSource(current.continueModelSource)
|
|
validateRuntimeSource(opencodeModelSource, 'OpenCode')
|
|
validateRuntimeSource(continueModelSource, 'Continue')
|
|
|
|
const next: StoredSettings = {
|
|
...current,
|
|
version: 13,
|
|
provider: input.provider,
|
|
modelProfiles,
|
|
defaultModelProfileId,
|
|
opencodeModelSource,
|
|
continueModelSource,
|
|
opencodeBaseUrl,
|
|
opencodeEmbedded: !opencodeBaseUrl,
|
|
opencodeBinaryPath,
|
|
opencodeConfigPath,
|
|
continueBinaryPath,
|
|
continueConfigPath,
|
|
continueMode: input.continueMode,
|
|
runtimeSandboxMode: input.runtimeSandboxMode,
|
|
subagentSmartRoutingEnabled:
|
|
input.subagentSmartRoutingEnabled ??
|
|
current.subagentSmartRoutingEnabled,
|
|
knowledgeEmbeddingEnabled: input.knowledgeEmbeddingEnabled,
|
|
knowledgeEmbeddingBaseUrl: embeddingEndpoint,
|
|
knowledgeEmbeddingModel: input.knowledgeEmbeddingModel,
|
|
knowledgeEmbeddingCredential,
|
|
workspacePath: input.workspacePath,
|
|
toolApproval: input.toolApproval
|
|
}
|
|
|
|
await mkdir(dirname(this.filePath), { recursive: true })
|
|
const temporaryPath = `${this.filePath}.${process.pid}.tmp`
|
|
try {
|
|
await writeFile(temporaryPath, `${JSON.stringify(next, null, 2)}\n`, {
|
|
encoding: 'utf8',
|
|
mode: 0o600
|
|
})
|
|
await rename(temporaryPath, this.filePath)
|
|
} finally {
|
|
await rm(temporaryPath, { force: true })
|
|
}
|
|
this.settings = next
|
|
this.loadWarning = undefined
|
|
return this.toPublicSettings(next)
|
|
}
|
|
|
|
private async canonicalizeRuntimeFile(
|
|
filePath: string,
|
|
label: string
|
|
): Promise<string> {
|
|
if (!filePath) {
|
|
return ''
|
|
}
|
|
try {
|
|
const canonicalPath = await realpath(filePath)
|
|
if (!(await stat(canonicalPath)).isFile()) {
|
|
throw new Error('Not a regular file')
|
|
}
|
|
return canonicalPath
|
|
} catch {
|
|
throw new Error(`${label}不存在、不可访问或不是普通文件`)
|
|
}
|
|
}
|
|
}
|