import {

LLM_KEY_POOLS,

OAUTH_CLIENT_CAPABILITIES,

resolveOAuthClientCapabilityId,

} from '../../apps/sim/lib/core/config/env-capabilities.ts'

import {

getCapabilitySetup,

getOAuthClientSetupFields,

SETUP_FEATURES,

type SetupFeatureId,

} from './capability-config.ts'

import { promptCapabilitySetup } from './capability-setup.ts'

import { type ConfigurationSource, discoverConfigurationSources } from './configuration-sources.ts'

import { type EnvTarget, reconcileEnvValues } from './env-files.ts'

import * as p from './prompter.ts'

import { theme } from './theme.ts'

function isSetupFeatureId(value: string): value is SetupFeatureId {

return SETUP_FEATURES.some((feature) => feature.id === value)

}

async function setupIntegration(

requestedId: string | undefined,

vars: Map<string, string>

): Promise<Record<string, string>> {

if (!requestedId) {

throw new Error('Missing integration id. Example: bun run setup integration slack')

}

const providerId = resolveOAuthClientCapabilityId(requestedId)

if (!providerId) {

throw new Error(

`Unknown OAuth integration "${requestedId}". Expected one of: ${Object.keys(OAUTH_CLIENT_CAPABILITIES).join(', ')}`

)

}

const fields = getOAuthClientSetupFields(providerId)

const values: Record<string, string> = {}

for (const field of fields) {

const existing = vars.get(field.key)

if (field.input === 'secret') {

const value = await p.password({

message: existing ? `${field.key} (Currently used); leave empty to keep it` : field.key,

validate: (candidate) => (candidate || existing ? undefined : 'required'),

})

const resolved = value || existing

if (!resolved) throw new Error(`${field.key} was not provided`)

values[field.key] = resolved

} else {

values[field.key] = await p.text({

message: `${field.key}${existing ? ' (Currently used)' : ''}`,

initialValue: existing,

validate: (candidate) => (candidate ? undefined : 'required'),

})

}

}

p.log.info(`Configured the ${providerId} OAuth client.`)

return values

}

type LlmKeyPoolId = keyof typeof LLM_KEY_POOLS

export interface LlmSetupResult {

remove: readonly string[]

values: Record<string, string>

}

/** Reconciles every rotation and legacy fallback key owned by the selected pool. */

export function reconcileLlmSetup(

providerId: LlmKeyPoolId,

values: Record<string, string>

): LlmSetupResult {

const pool = LLM_KEY_POOLS[providerId]

const fields = [...pool.keys, ...('fallbackKey' in pool ? [pool.fallbackKey] : [])]

return {

values,

remove: fields.filter((key) => !Object.hasOwn(values, key)),

}

}

async function setupLlm(vars: Map<string, string>): Promise<LlmSetupResult> {

const currentProvider = Object.entries(LLM_KEY_POOLS).find(([, pool]) =>

[...pool.keys, ...('fallbackKey' in pool ? [pool.fallbackKey] : [])].some((key) =>

vars.has(key)

)

)?.[0] as LlmKeyPoolId | undefined

const provider = await p.select<LlmKeyPoolId>({

message: 'LLM key pool?',

options: Object.keys(LLM_KEY_POOLS).map((id) => ({

value: id as LlmKeyPoolId,

label: id,

hint: id === currentProvider ? 'Currently used' : undefined,

})),

initialValue: currentProvider,

})

const pool = LLM_KEY_POOLS[provider]

const keys = pool.keys

const values: Record<string, string> = {}

for (const [index, key] of keys.entries()) {

const legacyKey = index === 0 && 'fallbackKey' in pool ? pool.fallbackKey : undefined

const existingKey = vars.has(key) ? key : legacyKey

const existing = existingKey ? vars.get(existingKey) : undefined

const value = await p.password({

message: existing

? `${key} (${existingKey} is currently used); leave empty to keep it`

: `${key}${index === 0 ? '' : ' (empty to finish)'}`,

validate:

index === 0 ? (candidate) => (candidate || existing ? undefined : 'required') : undefined,

})

const resolved = value || existing

if (!resolved) break

values[key] = resolved

}

return reconcileLlmSetup(provider, values)

}

export function setupFeatureUsage(): string {

return SETUP_FEATURES.map((feature) =>

feature.id === 'integration' ? 'integration <slug>' : feature.id

).join(' | ')

}

export interface FeatureSetupDestination {

source: ConfigurationSource

target: Extract<EnvTarget, 'sim' | 'root'>

vars: Map<string, string>

containerized: boolean

}

/** Resolves the one effective configuration this checkout can safely update. */

export function resolveFeatureSetupDestination(

sources: readonly ConfigurationSource[]

): FeatureSetupDestination {

if (sources.length === 0) {

throw new Error('No Sim configuration was detected. Run bun run setup first.')

}

const managed = sources.filter((source) => source.managedByCurrentCheckout)

if (managed.length === 0) {

throw new Error(

'No effective configuration is safely writable by this checkout. Process overrides, higher-precedence development env files, external Compose projects, and Helm releases must be updated at their source. Run bun run setup status for the detected sources.'

)

}

if (managed.length > 1) {

throw new Error(

`More than one effective configuration is writable by this checkout (${managed.map((source) => source.label).join(', ')}). Run bun run setup status and remove the ambiguity before configuring a feature.`

)

}

const source = managed[0]

if (!source.values) {

throw new Error(

`${source.label} is managed by this checkout, but its effective environment could not be resolved. Run bun run setup status and fix the reported source error first.`

)

}

if (source.kind === 'helm') {

throw new Error(

'Helm configuration cannot be updated by bun run setup. Update the release Secret or values and upgrade the release.'

)

}

return {

source,

target: source.kind === 'compose' ? 'root' : 'sim',

vars: source.values,

containerized: source.kind === 'compose',

}

}

export async function runFeatureSetup(feature: string, args: readonly string[]): Promise<void> {

if (!isSetupFeatureId(feature)) {

throw new Error(`Unknown setup feature "${feature}". Expected: ${setupFeatureUsage()}`)

}

const destination = resolveFeatureSetupDestination(discoverConfigurationSources())

const { target, vars } = destination

let values: Record<string, string>

let remove: readonly string[]

const capabilitySetup = getCapabilitySetup(feature)

if (capabilitySetup) {

const result = await promptCapabilitySetup(capabilitySetup, vars, {

containerized: destination.containerized,

})

values = result.values

remove = result.remove

} else if (feature === 'integration') {

values = await setupIntegration(args[0], vars)

remove = []

} else if (feature === 'llm') {

const result = await setupLlm(vars)

values = result.values

remove = result.remove

} else {

throw new Error(`Setup feature ${feature} has no handler`)

}

reconcileEnvValues(target, remove, values)

const label = SETUP_FEATURES.find((item) => item.id === feature)?.label

p.outro(

theme.accent(

destination.containerized

? `${label} written to .env. Recreate the app container for it to take effect.`

: `${label} configured.`

)

)

}