work-agent 0.1.0

package/lib/pi-config.ts

@@ -0,0 +1,436 @@
+/**
+ * PI Configuration Manager
+ *
+ * Manages loading and saving of pi-coding-agent configuration.
+ * Configuration files are located at ~/.pi/agent/ by default
+ * Can be overridden via PI_CONFIG_PATH environment variable
+ * - models.json: Custom model providers and API keys
+ * - auth.json: Runtime auth settings (fallback)
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir, tmpdir } from 'os';
+
+/**
+ * Get the home directory for configuration
+ * Priority: PI_CONFIG_PATH env > /root (for deployed environments) > HOME env > homedir()
+ */
+function getConfigDir(): string {
+	// 1. Explicit override via environment variable
+	if (process.env.PI_CONFIG_PATH) {
+		return process.env.PI_CONFIG_PATH;
+	}
+
+	// 2. Check if /root/.pi/agent exists (deployed environment)
+	const rootConfigDir = '/root/.pi/agent';
+	if (existsSync(rootConfigDir)) {
+		return rootConfigDir;
+	}
+
+	// 3. Use HOME environment variable
+	if (process.env.HOME) {
+		return join(process.env.HOME, '.pi', 'agent');
+	}
+
+	// 4. Use os.homedir()
+	const home = homedir();
+	if (home && home !== '/') {
+		return join(home, '.pi', 'agent');
+	}
+
+	// 5. Fallback to /root (for production deployments)
+	return '/root/.pi/agent';
+}
+
+// PI Agent config directory
+export const PI_CONFIG_DIR = getConfigDir();
+
+// Configuration file paths
+const MODELS_FILE = join(PI_CONFIG_DIR, 'models.json');
+
+/**
+ * Model provider configuration
+ */
+export interface ModelProvider {
+	baseUrl: string;
+	api: string;
+	apiKey: string;
+	models: Array<{ id: string }>;
+}
+
+/**
+ * Models.json structure
+ */
+export interface ModelsConfig {
+	providers: Record<string, ModelProvider>;
+}
+
+/**
+ * Loaded configuration with provider ID
+ */
+export interface ProviderConfig {
+	id: string;
+	name: string;
+	baseUrl: string;
+	api: string;
+	apiKey: string;
+	models: string[];
+}
+
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir(): void {
+	if (!existsSync(PI_CONFIG_DIR)) {
+		try {
+			mkdirSync(PI_CONFIG_DIR, { recursive: true });
+		} catch (error) {
+			console.error('Failed to create config directory:', error);
+		}
+	}
+}
+
+/**
+ * Default provider configurations (without API keys)
+ */
+export const DEFAULT_PROVIDERS: Record<string, Omit<ModelProvider, 'apiKey'>> = {
+	zhipu: {
+		baseUrl: 'https://open.bigmodel.cn/api/anthropic',
+		api: 'anthropic-messages',
+		models: [{ id: 'glm-4.7' }],
+	},
+	anthropic: {
+		baseUrl: 'https://api.anthropic.com',
+		api: 'anthropic-messages',
+		models: [{ id: 'claude-sonnet-4-20250514' }],
+	},
+	deepseek: {
+		baseUrl: 'https://api.deepseek.com',
+		api: 'openai-completions',
+		models: [{ id: 'deepseek-chat' }],
+	},
+	openai: {
+		baseUrl: 'https://api.openai.com/v1',
+		api: 'openai-completions',
+		models: [{ id: 'gpt-4o' }],
+	},
+	ollama: {
+		baseUrl: 'http://192.168.44.151:11434/v1',
+		api: 'openai-completions',
+		models: [{ id: 'qwen3.5:27b' }],
+	},
+};
+
+/**
+ * Get default configuration from environment variables
+ *
+ * Supported environment variables (AI_ prefix):
+ * - AI_PROVIDER: Provider ID (zhipu, anthropic, deepseek, openai, ollama, or custom)
+ * - AI_MODEL: Model ID (e.g., glm-4, claude-sonnet-4-20250514, qwen3.5:27b)
+ * - AI_BASE_URL: Custom API base URL
+ * - AI_API_KEY: Generic API key (lower priority than provider-specific keys)
+ *
+ * Legacy environment variables (still supported):
+ * - ZHIPU_API_KEY: Zhipu AI API key
+ * - ANTHROPIC_API_KEY: Anthropic API key
+ */
+function getDefaultConfigFromEnv(): ModelsConfig | null {
+	// Check for new AI_ prefix environment variables first
+	const aiProvider = process.env.AI_PROVIDER;
+	const aiModel = process.env.AI_MODEL;
+	const aiBaseUrl = process.env.AI_BASE_URL;
+	const aiApiKey = process.env.AI_API_KEY;
+
+	// If AI_PROVIDER is set, use the new configuration system
+	if (aiProvider) {
+		const providerId = aiProvider.toLowerCase();
+		const defaultProvider = DEFAULT_PROVIDERS[providerId];
+
+		// Determine API key: provider-specific key > AI_API_KEY
+		let apiKey = aiApiKey;
+		if (providerId === 'zhipu' && process.env.ZHIPU_API_KEY) {
+			apiKey = process.env.ZHIPU_API_KEY;
+		} else if (providerId === 'anthropic' && process.env.ANTHROPIC_API_KEY) {
+			apiKey = process.env.ANTHROPIC_API_KEY;
+		}
+
+		if (!apiKey) {
+			console.warn(`AI_PROVIDER is set to "${providerId}" but no API key found. Set AI_API_KEY or ${providerId.toUpperCase()}_API_KEY`);
+			return null;
+		}
+
+		console.log(`Using AI_PROVIDER=${providerId} from environment`);
+
+		return {
+			providers: {
+				[providerId]: {
+					baseUrl: aiBaseUrl || defaultProvider?.baseUrl || '',
+					api: defaultProvider?.api || 'anthropic-messages',
+					apiKey,
+					models: [{ id: aiModel || defaultProvider?.models?.[0]?.id || 'default' }],
+				},
+			},
+		};
+	}
+
+	// Fallback to legacy environment variables
+	// Priority: ZHIPU_API_KEY > ANTHROPIC_API_KEY
+	const zhipuKey = process.env.ZHIPU_API_KEY;
+	if (zhipuKey) {
+		console.log('Using ZHIPU_API_KEY from environment');
+		return {
+			providers: {
+				zhipu: {
+					...DEFAULT_PROVIDERS.zhipu,
+					apiKey: zhipuKey,
+				},
+			},
+		};
+	}
+
+	const anthropicKey = process.env.ANTHROPIC_API_KEY;
+	if (anthropicKey) {
+		console.log('Using ANTHROPIC_API_KEY from environment');
+		return {
+			providers: {
+				anthropic: {
+					...DEFAULT_PROVIDERS.anthropic,
+					apiKey: anthropicKey,
+				},
+			},
+		};
+	}
+
+	return null;
+}
+
+/**
+ * Load models.json configuration
+ */
+export function loadModelsConfig(): ModelsConfig | null {
+	try {
+		console.log('[pi-config] === Loading configuration ===');
+		console.log('[pi-config] HOME env:', process.env.HOME || 'not set');
+		console.log('[pi-config] USER env:', process.env.USER || 'not set');
+		console.log('[pi-config] PI_CONFIG_PATH env:', process.env.PI_CONFIG_PATH || 'not set');
+		console.log('[pi-config] Computed PI_CONFIG_DIR:', PI_CONFIG_DIR);
+		console.log('[pi-config] MODELS_FILE path:', MODELS_FILE);
+
+		if (!existsSync(MODELS_FILE)) {
+			console.log('[pi-config] models.json not found at', MODELS_FILE);
+			console.log('[pi-config] Checking environment variables...');
+			const envConfig = getDefaultConfigFromEnv();
+			if (envConfig) {
+				console.log('[pi-config] Using config from environment variables');
+			} else {
+				console.log('[pi-config] No configuration found!');
+			}
+			return envConfig;
+		}
+
+		console.log('[pi-config] models.json found, reading...');
+		const content = readFileSync(MODELS_FILE, 'utf-8');
+		console.log('[pi-config] models.json content length:', content.length);
+
+		const config = JSON.parse(content) as ModelsConfig;
+		console.log('[pi-config] Parsed providers:', Object.keys(config.providers || {}));
+
+		// Validate and log configuration
+		for (const [id, provider] of Object.entries(config.providers || {})) {
+			if (!provider.apiKey) {
+				console.warn(`[pi-config] Provider ${id} has no apiKey!`);
+			} else {
+				const key = provider.apiKey;
+				const maskedKey = key.length > 20
+					? `${key.substring(0, 10)}...${key.substring(key.length - 10)}`
+					: '***';
+				console.log(`[pi-config] Provider ${id}:`);
+				console.log(`[pi-config]   baseUrl: ${provider.baseUrl}`);
+				console.log(`[pi-config]   api: ${provider.api}`);
+				console.log(`[pi-config]   apiKey: ${maskedKey} (length: ${key.length})`);
+				console.log(`[pi-config]   models: ${provider.models?.map(m => m.id).join(', ')}`);
+			}
+		}
+
+		return config;
+	} catch (error) {
+		console.error('[pi-config] Failed to load models.json:', error);
+		return getDefaultConfigFromEnv();
+	}
+}
+
+/**
+ * Save models.json configuration
+ */
+export function saveModelsConfig(config: ModelsConfig): boolean {
+	try {
+		ensureConfigDir();
+
+		// Validate config before saving
+		if (!config.providers || Object.keys(config.providers).length === 0) {
+			throw new Error('Invalid config: providers is required');
+		}
+
+		// Validate each provider
+		for (const [id, provider] of Object.entries(config.providers)) {
+			if (!provider.baseUrl || !provider.apiKey) {
+				throw new Error(`Invalid provider ${id}: baseUrl and apiKey are required`);
+			}
+		}
+
+		writeFileSync(MODELS_FILE, JSON.stringify(config, null, 2), 'utf-8');
+		console.log('Saved models.json');
+		return true;
+	} catch (error) {
+		console.error('Failed to save models.json:', error);
+		throw error;
+	}
+}
+
+/**
+ * Get all available providers from models.json
+ */
+export function getAvailableProviders(): ProviderConfig[] {
+	const config = loadModelsConfig();
+	if (!config || !config.providers) {
+		return [];
+	}
+
+	const providers: ProviderConfig[] = [];
+
+	for (const [id, provider] of Object.entries(config.providers)) {
+		providers.push({
+			id,
+			name: getProviderDisplayName(id),
+			baseUrl: provider.baseUrl,
+			api: provider.api,
+			apiKey: provider.apiKey,
+			models: provider.models?.map(m => m.id) || [],
+		});
+	}
+
+	return providers;
+}
+
+/**
+ * Get provider display name
+ */
+function getProviderDisplayName(id: string): string {
+	const names: Record<string, string> = {
+		'anthropic': 'Anthropic (Claude)',
+		'openai': 'OpenAI (GPT)',
+		'zhipu': '智谱 AI (GLM)',
+		'deepseek': 'DeepSeek',
+		'ollama': 'Ollama (Local)',
+	};
+
+	return names[id] || id.charAt(0).toUpperCase() + id.slice(1);
+}
+
+/**
+ * Get default provider (first one in the list)
+ */
+export function getDefaultProvider(): ProviderConfig | null {
+	const providers = getAvailableProviders();
+	return providers.length > 0 ? providers[0] : null;
+}
+
+/**
+ * Get provider by ID
+ */
+export function getProviderById(id: string): ProviderConfig | null {
+	const providers = getAvailableProviders();
+	return providers.find(p => p.id === id) || null;
+}
+
+/**
+ * Update or add a provider
+ */
+export function upsertProvider(
+	id: string,
+	provider: Omit<ModelProvider, 'models'> & { models?: string[] }
+): ModelsConfig {
+	const config = loadModelsConfig() || { providers: {} };
+
+	config.providers[id] = {
+		baseUrl: provider.baseUrl,
+		api: provider.api,
+		apiKey: provider.apiKey,
+		models: (provider.models || []).map(m => ({ id: m })),
+	};
+
+	saveModelsConfig(config);
+	return config;
+}
+
+/**
+ * Delete a provider
+ */
+export function deleteProvider(id: string): ModelsConfig | null {
+	const config = loadModelsConfig();
+	if (!config || !config.providers[id]) {
+		return null;
+	}
+
+	delete config.providers[id];
+	saveModelsConfig(config);
+	return config;
+}
+
+/**
+ * Get configuration for AuthStorage
+ * Returns the first available provider's API key and base URL
+ */
+export function getAuthConfig(): { apiKey: string; baseUrl?: string } | null {
+	const provider = getDefaultProvider();
+	if (!provider) {
+		return null;
+	}
+
+	return {
+		apiKey: provider.apiKey,
+		baseUrl: provider.baseUrl,
+	};
+}
+
+/**
+ * Validate provider configuration
+ */
+export function validateProvider(provider: Partial<ModelProvider>): { valid: boolean; errors: string[] } {
+	const errors: string[] = [];
+
+	if (!provider.baseUrl) {
+		errors.push('baseUrl is required');
+	}
+
+	if (!provider.apiKey) {
+		errors.push('apiKey is required');
+	}
+
+	if (!provider.api) {
+		errors.push('api is required');
+	}
+
+	// Validate URL format
+	if (provider.baseUrl && !isValidUrl(provider.baseUrl)) {
+		errors.push('baseUrl must be a valid URL');
+	}
+
+	return {
+		valid: errors.length === 0,
+		errors,
+	};
+}
+
+/**
+ * Check if string is a valid URL
+ */
+function isValidUrl(url: string): boolean {
+	try {
+		new URL(url);
+		return true;
+	} catch {
+		return false;
+	}
+}