@meistrari/tela-cli 0.1.0

package/src/config.ts

@@ -0,0 +1,384 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { isAbsolute, join } from 'node:path'
+import type { TelaCliConfig } from './types.ts'
+
+const CONFIG_FILENAME = 'tela-cli.json'
+export const AGENT_API_PRESET_URLS = {
+    production: 'https://agent-api.tela.com',
+    staging: 'https://agent-api-staging.tela.com',
+} as const
+export type AgentApiPreset = keyof typeof AGENT_API_PRESET_URLS | 'custom'
+export const DEFAULT_AGENT_API_URL = AGENT_API_PRESET_URLS.production
+export const AGENT_API_BROWSER_HELP = 'API-only endpoint; browser navigation is not expected.'
+const AGENT_API_PRESET_ALIASES: Record<Exclude<AgentApiPreset, 'custom'>, string[]> = {
+    production: [AGENT_API_PRESET_URLS.production],
+    staging: [
+        AGENT_API_PRESET_URLS.staging,
+        'https://agent-api-staging.tela.com',
+    ],
+}
+const DEFAULT_CLONE_ROOT_SEGMENTS = ['Code', 'Tela']
+
+export interface TextPromptOptions {
+    message: string
+    defaultValue?: string
+    placeholder?: string
+    validate?: (value: string) => string | undefined
+}
+
+export interface PasswordPromptOptions extends TextPromptOptions {
+    mask?: string
+}
+
+export interface Option<T> {
+    value: T
+    label: string
+    hint?: string
+}
+
+export interface SelectOptions<T> {
+    message: string
+    options: Array<Option<T>>
+    initialValue?: T
+}
+
+export interface ConfigInspection {
+    path: string
+    exists: boolean
+    valid: boolean
+    config?: TelaCliConfig
+    error?: string
+}
+
+export interface PromptModule {
+    intro(message: string): void
+    outro(message: string): void
+    cancel(message: string): void
+    isCancel(value: unknown): boolean
+    note?(message: string, title?: string): void
+    select<T>(options: SelectOptions<T>): Promise<T | symbol>
+    text(options: TextPromptOptions): Promise<string | symbol>
+    password(options: PasswordPromptOptions): Promise<string | symbol>
+}
+
+function promptValue<T>(value: T | symbol): T {
+    return value as T
+}
+
+export function ensureAbsoluteUrl(value: string, label: string): string {
+    let url: URL
+    try {
+        url = new URL(value)
+    }
+    catch {
+        throw new Error(`${label} must be a valid URL`)
+    }
+
+    return url.toString().replace(/\/$/, '')
+}
+
+export const AGENT_API_PRESET_OPTIONS: Array<Option<AgentApiPreset>> = [
+    {
+        value: 'production',
+        label: 'Production',
+        hint: AGENT_API_PRESET_URLS.production,
+    },
+    {
+        value: 'staging',
+        label: 'Staging',
+        hint: AGENT_API_PRESET_URLS.staging,
+    },
+    {
+        value: 'custom',
+        label: 'Custom',
+        hint: 'Enter a custom API origin URL',
+    },
+]
+
+export function inferAgentApiPreset(agentApiUrl: string | null | undefined): AgentApiPreset {
+    if (!agentApiUrl) {
+        return 'production'
+    }
+
+    let normalized = agentApiUrl.trim()
+    try {
+        normalized = ensureAbsoluteUrl(normalized, 'Agent API origin URL')
+    }
+    catch {
+        return 'custom'
+    }
+
+    for (const preset of ['production', 'staging'] as const) {
+        if (AGENT_API_PRESET_ALIASES[preset].includes(normalized)) {
+            return preset
+        }
+    }
+
+    return 'custom'
+}
+
+export function resolveAgentApiUrlForPreset(preset: AgentApiPreset, customUrl = ''): string {
+    switch (preset) {
+        case 'production':
+            return AGENT_API_PRESET_URLS.production
+        case 'staging':
+            return AGENT_API_PRESET_URLS.staging
+        case 'custom':
+            return ensureAbsoluteUrl(customUrl, 'Agent API origin URL')
+    }
+}
+
+function ensureNonEmpty(value: string, label: string): string {
+    const normalized = value.trim()
+    if (!normalized) {
+        throw new Error(`${label} is required`)
+    }
+
+    return normalized
+}
+
+function getHomeDir(): string {
+    return process.env.HOME || homedir()
+}
+
+function getTelaDir(): string {
+    return join(getHomeDir(), '.tela')
+}
+
+export function getDefaultCloneRoot(): string {
+    return join(getHomeDir(), ...DEFAULT_CLONE_ROOT_SEGMENTS)
+}
+
+export function resolveCloneRoot(value: string): string {
+    const expanded = expandHome(ensureNonEmpty(value, 'Clone root'))
+    return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded)
+}
+
+export function validateAgentApiUrl(value: string): string | undefined {
+    try {
+        ensureAbsoluteUrl(value, 'Agent API origin URL')
+        return undefined
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : 'Invalid URL'
+    }
+}
+
+export function validateCloneRoot(value: string): string | undefined {
+    try {
+        resolveCloneRoot(value)
+        return undefined
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : 'Invalid directory'
+    }
+}
+
+export function validateApiKey(value: string, existingApiKey?: string): string | undefined {
+    const nextValue = value.trim() || existingApiKey || ''
+    return nextValue ? undefined : 'API key is required'
+}
+
+function normalizeConfig(config: TelaCliConfig): TelaCliConfig {
+    return {
+        agentApiUrl: ensureAbsoluteUrl(config.agentApiUrl, 'Agent API origin URL'),
+        cloneRoot: resolveCloneRoot(config.cloneRoot),
+        apiKey: ensureNonEmpty(config.apiKey, 'API key'),
+    }
+}
+
+function parseJsonConfig(input: string): TelaCliConfig {
+    const parsed = JSON.parse(input) as Partial<Record<keyof TelaCliConfig, unknown>>
+
+    return normalizeConfig({
+        agentApiUrl: String(parsed.agentApiUrl ?? ''),
+        cloneRoot: String(parsed.cloneRoot ?? ''),
+        apiKey: String(parsed.apiKey ?? ''),
+    })
+}
+
+function tryLoadConfig(): TelaCliConfig | null {
+    try {
+        return loadConfig()
+    }
+    catch {
+        return null
+    }
+}
+
+function cancelSetup(prompts: PromptModule): never {
+    prompts.cancel('Setup cancelled.')
+    throw new Error('Setup cancelled')
+}
+
+export function getConfigPath(): string {
+    return join(getTelaDir(), CONFIG_FILENAME)
+}
+
+export function expandHome(input: string): string {
+    if (input === '~') {
+        return getHomeDir()
+    }
+
+    if (input.startsWith('~/')) {
+        return join(getHomeDir(), input.slice(2))
+    }
+
+    return input
+}
+
+export function redactApiKey(apiKey: string): string {
+    const trimmed = apiKey.trim()
+    if (!trimmed) {
+        return '<missing>'
+    }
+
+    if (trimmed.length <= 8) {
+        return `${trimmed.slice(0, 2)}***${trimmed.slice(-2)}`
+    }
+
+    return `${trimmed.slice(0, 4)}***${trimmed.slice(-4)}`
+}
+
+export function loadConfig(): TelaCliConfig | null {
+    const configPath = getConfigPath()
+    if (!existsSync(configPath)) {
+        return null
+    }
+
+    return parseJsonConfig(readFileSync(configPath, 'utf-8'))
+}
+
+export function inspectSavedConfig(): ConfigInspection {
+    const path = getConfigPath()
+
+    if (!existsSync(path)) {
+        return {
+            path,
+            exists: false,
+            valid: false,
+        }
+    }
+
+    try {
+        const config = loadConfig()
+        return {
+            path,
+            exists: true,
+            valid: Boolean(config),
+            config: config ?? undefined,
+        }
+    }
+    catch (error) {
+        return {
+            path,
+            exists: true,
+            valid: false,
+            error: error instanceof Error ? error.message : String(error),
+        }
+    }
+}
+
+export function saveConfig(config: TelaCliConfig): void {
+    const telaDir = getTelaDir()
+    mkdirSync(telaDir, { recursive: true, mode: 0o700 })
+
+    const normalized = normalizeConfig(config)
+    const configPath = getConfigPath()
+    writeFileSync(configPath, `${JSON.stringify(normalized, null, 2)}\n`, { mode: 0o600 })
+    chmodSync(configPath, 0o600)
+}
+
+export async function setupConfigInteractive(options: {
+    prompts?: PromptModule
+    existingConfig?: TelaCliConfig | null
+    skipLifecycle?: boolean
+} = {}): Promise<TelaCliConfig> {
+    const prompts = options.prompts
+    if (!prompts) {
+        throw new Error('Interactive prompts are not available without a prompt implementation.')
+    }
+    const existingConfig = options.existingConfig ?? tryLoadConfig()
+
+    if (!options.skipLifecycle) {
+        prompts.intro('Tela CLI setup')
+    }
+
+    prompts.note?.(AGENT_API_BROWSER_HELP, 'Agent API')
+    const initialAgentApiPreset = inferAgentApiPreset(existingConfig?.agentApiUrl ?? DEFAULT_AGENT_API_URL)
+    const agentApiPresetResult = await prompts.select<AgentApiPreset>({
+        message: 'Agent API target',
+        initialValue: initialAgentApiPreset,
+        options: AGENT_API_PRESET_OPTIONS,
+    })
+
+    if (prompts.isCancel(agentApiPresetResult)) {
+        cancelSetup(prompts)
+    }
+
+    const agentApiPreset = promptValue(agentApiPresetResult)
+    let agentApiUrl = agentApiPreset === 'custom'
+        ? (initialAgentApiPreset === 'custom' ? (existingConfig?.agentApiUrl ?? '') : '')
+        : resolveAgentApiUrlForPreset(agentApiPreset)
+    if (agentApiPreset === 'custom') {
+        prompts.note?.(AGENT_API_BROWSER_HELP, 'Agent API origin')
+        const customAgentApiUrlResult = await prompts.text({
+            message: 'Custom Agent API origin URL',
+            defaultValue: initialAgentApiPreset === 'custom' ? existingConfig?.agentApiUrl : undefined,
+            validate: validateAgentApiUrl,
+        })
+
+        if (prompts.isCancel(customAgentApiUrlResult)) {
+            cancelSetup(prompts)
+        }
+
+        agentApiUrl = resolveAgentApiUrlForPreset('custom', promptValue(customAgentApiUrlResult))
+    }
+
+    const cloneRootResult = await prompts.text({
+        message: 'Clone root directory',
+        defaultValue: existingConfig?.cloneRoot ?? getDefaultCloneRoot(),
+        validate: validateCloneRoot,
+    })
+
+    if (prompts.isCancel(cloneRootResult)) {
+        cancelSetup(prompts)
+    }
+
+    const apiKeyResult = await prompts.password({
+        message: existingConfig?.apiKey ? 'API key' : 'API key',
+        placeholder: existingConfig?.apiKey ? 'Leave blank to keep the current API key' : undefined,
+        mask: '*',
+        validate: value => validateApiKey(value, existingConfig?.apiKey),
+    })
+
+    if (prompts.isCancel(apiKeyResult)) {
+        cancelSetup(prompts)
+    }
+
+    const config = normalizeConfig({
+        agentApiUrl,
+        cloneRoot: promptValue(cloneRootResult),
+        apiKey: promptValue(apiKeyResult).trim() || existingConfig?.apiKey || '',
+    })
+
+    saveConfig(config)
+    if (!options.skipLifecycle) {
+        prompts.outro('Tela CLI configured')
+    }
+    return config
+}
+
+export async function ensureConfigInteractive(
+    options: {
+        prompts?: PromptModule
+    } = {},
+): Promise<TelaCliConfig> {
+    const existing = tryLoadConfig()
+    if (existing) {
+        return existing
+    }
+
+    return await setupConfigInteractive(options)
+}