@orchid-labs/pluxx 0.1.0 → 0.1.3

package/src/user-config.ts

@@ -1,177 +0,0 @@
-import type { McpServer, PluginConfig, TargetPlatform, UserConfigEntry } from './schema'
-
-export interface ResolvedUserConfigEntry {
-  field: UserConfigEntry
-  value: string | number | boolean
-  envVar?: string
-}
-
-interface DerivedUserConfigEntry extends UserConfigEntry {
-  source: 'explicit' | 'mcp-auth' | 'mcp-env'
-}
-
-const ENV_VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/
-
-export function normalizeUserConfigKey(value: string): string {
-  return value
-    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
-    .replace(/[._/\s]+/g, '-')
-    .toLowerCase()
-    .replace(/[^a-z0-9-]+/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-+|-+$/g, '')
-}
-
-export function humanizeUserConfigLabel(value: string): string {
-  return value
-    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
-    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
-    .replace(/[._/]+/g, ' ')
-    .replace(/-/g, ' ')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
-    .join(' ')
-}
-
-export function defaultUserConfigEnvVar(key: string): string {
-  return key
-    .replace(/[^A-Za-z0-9]+/g, '_')
-    .replace(/_+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    .toUpperCase()
-}
-
-export function extractEnvReference(value: string | undefined): string | undefined {
-  if (!value) return undefined
-  const match = value.match(/^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/)
-  return match?.[1]
-}
-
-function isRuntimePlatformManaged(config: PluginConfig, target: TargetPlatform, server: McpServer): boolean {
-  if (server.transport === 'stdio') return false
-
-  if (server.auth?.type === 'platform') {
-    return true
-  }
-
-  if (target === 'claude-code') {
-    return config.platforms?.['claude-code']?.mcpAuth === 'platform'
-  }
-
-  if (target === 'cursor') {
-    return config.platforms?.cursor?.mcpAuth === 'platform'
-  }
-
-  return false
-}
-
-function targetApplies(entry: UserConfigEntry, target: TargetPlatform): boolean {
-  return !entry.targets || entry.targets.includes(target)
-}
-
-function dedupeUserConfigEntries(entries: DerivedUserConfigEntry[]): DerivedUserConfigEntry[] {
-  const deduped: DerivedUserConfigEntry[] = []
-  const seenKeys = new Set<string>()
-  const seenEnvVars = new Set<string>()
-
-  for (const entry of entries) {
-    const envVar = entry.envVar?.trim()
-
-    if (seenKeys.has(entry.key)) continue
-    if (envVar && seenEnvVars.has(envVar)) continue
-
-    deduped.push(entry)
-    seenKeys.add(entry.key)
-    if (envVar) seenEnvVars.add(envVar)
-  }
-
-  return deduped
-}
-
-export function collectUserConfigEntries(
-  config: PluginConfig,
-  platforms: TargetPlatform[] = config.targets,
-): DerivedUserConfigEntry[] {
-  const explicitEntries = (config.userConfig ?? [])
-    .filter((entry) => !entry.targets || entry.targets.some((target) => platforms.includes(target)))
-    .map((entry) => ({ ...entry, source: 'explicit' as const }))
-
-  const derivedEntries: DerivedUserConfigEntry[] = []
-
-  for (const [serverName, server] of Object.entries(config.mcp ?? {})) {
-    const applicableTargets = platforms.filter((target) => !isRuntimePlatformManaged(config, target, server))
-
-    if (
-      server.auth?.type
-      && server.auth.type !== 'none'
-      && server.auth.type !== 'platform'
-      && ENV_VAR_NAME.test(server.auth.envVar)
-      && applicableTargets.length > 0
-    ) {
-      derivedEntries.push({
-        key: normalizeUserConfigKey(server.auth.envVar),
-        title: humanizeUserConfigLabel(server.auth.envVar),
-        description: `Authentication credential for the ${serverName} MCP server.`,
-        type: 'secret',
-        required: true,
-        envVar: server.auth.envVar,
-        targets: applicableTargets,
-        source: 'mcp-auth',
-      })
-    }
-
-    if (server.transport === 'stdio') {
-      for (const [key, rawValue] of Object.entries(server.env ?? {})) {
-        const envVar = extractEnvReference(rawValue) ?? (ENV_VAR_NAME.test(key) ? key : undefined)
-        if (!envVar || !ENV_VAR_NAME.test(envVar)) continue
-
-        // Skip constant stdio env values that do not need install-time input.
-        if (extractEnvReference(rawValue) === undefined && rawValue !== '') {
-          continue
-        }
-
-        derivedEntries.push({
-          key: normalizeUserConfigKey(envVar),
-          title: humanizeUserConfigLabel(envVar),
-          description: `Environment value required to launch the ${serverName} stdio MCP server.`,
-          type: 'secret',
-          required: true,
-          envVar,
-          targets: applicableTargets.length > 0 ? applicableTargets : platforms,
-          source: 'mcp-env',
-        })
-      }
-    }
-  }
-
-  return dedupeUserConfigEntries([
-    ...explicitEntries,
-    ...derivedEntries,
-  ])
-}
-
-export function resolveUserConfigEntriesForTarget(
-  entries: ResolvedUserConfigEntry[],
-  target: TargetPlatform,
-): ResolvedUserConfigEntry[] {
-  return entries.filter(({ field }) => targetApplies(field, target))
-}
-
-export function buildUserConfigEnvMap(entries: ResolvedUserConfigEntry[]): Record<string, string> {
-  const env: Record<string, string> = {}
-  for (const entry of entries) {
-    if (!entry.envVar) continue
-    env[entry.envVar] = String(entry.value)
-  }
-  return env
-}
-
-export function buildUserConfigValueMap(entries: ResolvedUserConfigEntry[]): Record<string, string | number | boolean> {
-  const values: Record<string, string | number | boolean> = {}
-  for (const entry of entries) {
-    values[entry.field.key] = entry.value
-  }
-  return values
-}