cyrus-config-updater 0.2.0-rc

package/src/ConfigUpdater.ts

@@ -0,0 +1,156 @@
+import type { FastifyInstance } from "fastify";
+import { handleCheckGh } from "./handlers/checkGh.js";
+import { handleConfigureMcp } from "./handlers/configureMcp.js";
+import { handleCyrusConfig } from "./handlers/cyrusConfig.js";
+import { handleCyrusEnv } from "./handlers/cyrusEnv.js";
+import { handleRepository } from "./handlers/repository.js";
+import { handleTestMcp } from "./handlers/testMcp.js";
+import type {
+	ApiResponse,
+	CheckGhPayload,
+	ConfigureMcpPayload,
+	CyrusConfigPayload,
+	CyrusEnvPayload,
+	RepositoryPayload,
+	TestMcpPayload,
+} from "./types.js";
+
+/**
+ * ConfigUpdater registers configuration update routes with a Fastify server
+ * Handles: cyrus-config, cyrus-env, repository, test-mcp, configure-mcp, check-gh endpoints
+ */
+export class ConfigUpdater {
+	private fastify: FastifyInstance;
+	private cyrusHome: string;
+	private apiKey: string;
+
+	constructor(fastify: FastifyInstance, cyrusHome: string, apiKey: string) {
+		this.fastify = fastify;
+		this.cyrusHome = cyrusHome;
+		this.apiKey = apiKey;
+	}
+
+	/**
+	 * Register all configuration update routes with the Fastify instance
+	 */
+	register(): void {
+		// Register all routes with authentication
+		this.registerRoute("/api/update/cyrus-config", this.handleCyrusConfigRoute);
+		this.registerRoute("/api/update/cyrus-env", this.handleCyrusEnvRoute);
+		this.registerRoute("/api/update/repository", this.handleRepositoryRoute);
+		this.registerRoute("/api/test-mcp", this.handleTestMcpRoute);
+		this.registerRoute("/api/configure-mcp", this.handleConfigureMcpRoute);
+		this.registerRoute("/api/check-gh", this.handleCheckGhRoute);
+	}
+
+	/**
+	 * Register a route with authentication
+	 */
+	private registerRoute(
+		path: string,
+		handler: (payload: any) => Promise<ApiResponse>,
+	): void {
+		this.fastify.post(path, async (request, reply) => {
+			// Verify authentication
+			const authHeader = request.headers.authorization;
+			if (!this.verifyAuth(authHeader)) {
+				return reply.status(401).send({
+					success: false,
+					error: "Unauthorized",
+				});
+			}
+
+			try {
+				const response = await handler.call(this, request.body);
+				const statusCode = response.success ? 200 : 400;
+				return reply.status(statusCode).send(response);
+			} catch (error) {
+				return reply.status(500).send({
+					success: false,
+					error: "Internal server error",
+					details: error instanceof Error ? error.message : String(error),
+				});
+			}
+		});
+	}
+
+	/**
+	 * Verify Bearer token authentication
+	 */
+	private verifyAuth(authHeader: string | undefined): boolean {
+		if (!authHeader || !this.apiKey) {
+			return false;
+		}
+
+		const expectedAuth = `Bearer ${this.apiKey}`;
+		return authHeader === expectedAuth;
+	}
+
+	/**
+	 * Handle cyrus-config update
+	 */
+	private async handleCyrusConfigRoute(
+		payload: CyrusConfigPayload,
+	): Promise<ApiResponse> {
+		const response = await handleCyrusConfig(payload, this.cyrusHome);
+
+		// Emit restart event if requested
+		if (response.success && response.data?.restartCyrus) {
+			this.fastify.log.info("Config update requested Cyrus restart");
+		}
+
+		return response;
+	}
+
+	/**
+	 * Handle cyrus-env update
+	 */
+	private async handleCyrusEnvRoute(
+		payload: CyrusEnvPayload,
+	): Promise<ApiResponse> {
+		const response = await handleCyrusEnv(payload, this.cyrusHome);
+
+		// Emit restart event if requested
+		if (response.success && response.data?.restartCyrus) {
+			this.fastify.log.info("Env update requested Cyrus restart");
+		}
+
+		return response;
+	}
+
+	/**
+	 * Handle repository clone/verify
+	 */
+	private async handleRepositoryRoute(
+		payload: RepositoryPayload,
+	): Promise<ApiResponse> {
+		return handleRepository(payload, this.cyrusHome);
+	}
+
+	/**
+	 * Handle MCP connection test
+	 */
+	private async handleTestMcpRoute(
+		payload: TestMcpPayload,
+	): Promise<ApiResponse> {
+		return handleTestMcp(payload);
+	}
+
+	/**
+	 * Handle MCP server configuration
+	 */
+	private async handleConfigureMcpRoute(
+		payload: ConfigureMcpPayload,
+	): Promise<ApiResponse> {
+		return handleConfigureMcp(payload, this.cyrusHome);
+	}
+
+	/**
+	 * Handle GitHub CLI check
+	 */
+	private async handleCheckGhRoute(
+		payload: CheckGhPayload,
+	): Promise<ApiResponse> {
+		return handleCheckGh(payload, this.cyrusHome);
+	}
+}

package/src/handlers/checkGh.ts

@@ -0,0 +1,59 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import type { ApiResponse, CheckGhData, CheckGhPayload } from "../types.js";
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if GitHub CLI (gh) is installed and authenticated
+ *
+ * @param _payload - Empty payload (no parameters needed)
+ * @param _cyrusHome - Cyrus home directory (not used)
+ * @returns ApiResponse with installation and authentication status
+ */
+export async function handleCheckGh(
+	_payload: CheckGhPayload,
+	_cyrusHome: string,
+): Promise<ApiResponse> {
+	try {
+		// Check if gh is installed
+		let isInstalled = false;
+		try {
+			await execAsync("gh --version");
+			isInstalled = true;
+		} catch {
+			// gh command not found
+			isInstalled = false;
+		}
+
+		// Check if gh is authenticated (only if installed)
+		let isAuthenticated = false;
+		if (isInstalled) {
+			try {
+				// Run 'gh auth status' and check exit code
+				await execAsync("gh auth status");
+				isAuthenticated = true;
+			} catch {
+				// gh auth status failed (not authenticated)
+				isAuthenticated = false;
+			}
+		}
+
+		const data: CheckGhData = {
+			isInstalled,
+			isAuthenticated,
+		};
+
+		return {
+			success: true,
+			message: "GitHub CLI check completed",
+			data,
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: "Failed to check GitHub CLI status",
+			details: error instanceof Error ? error.message : String(error),
+		};
+	}
+}

package/src/handlers/configureMcp.ts

@@ -0,0 +1,127 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ApiResponse, ConfigureMcpPayload } from "../types.js";
+
+/**
+ * Handle MCP server configuration
+ * Writes individual MCP config files to ~/.cyrus/mcp-{slug}.json
+ */
+export async function handleConfigureMcp(
+	payload: ConfigureMcpPayload,
+	cyrusHome: string,
+): Promise<ApiResponse> {
+	try {
+		// Validate payload
+		if (!payload.mcpServers || typeof payload.mcpServers !== "object") {
+			return {
+				success: false,
+				error: "MCP configuration requires server definitions",
+				details:
+					"The mcpServers field must be an object containing server configurations.",
+			};
+		}
+
+		const serverSlugs = Object.keys(payload.mcpServers);
+		if (serverSlugs.length === 0) {
+			return {
+				success: false,
+				error: "No MCP servers to configure",
+				details: "At least one MCP server configuration must be provided.",
+			};
+		}
+
+		// Ensure the .cyrus directory exists
+		if (!existsSync(cyrusHome)) {
+			mkdirSync(cyrusHome, { recursive: true });
+		}
+
+		const mcpFilesWritten: string[] = [];
+
+		// Write each MCP server configuration to its own file
+		for (const slug of serverSlugs) {
+			const serverConfig = payload.mcpServers[slug];
+			const mcpFilePath = join(cyrusHome, `mcp-${slug}.json`);
+
+			// Perform environment variable substitution
+			const processedConfig = performEnvSubstitution(serverConfig);
+
+			// Write the config file
+			try {
+				const configData = {
+					mcpServers: {
+						[slug]: processedConfig,
+					},
+				};
+
+				writeFileSync(
+					mcpFilePath,
+					JSON.stringify(configData, null, 2),
+					"utf-8",
+				);
+
+				mcpFilesWritten.push(mcpFilePath);
+			} catch (error) {
+				return {
+					success: false,
+					error: `Failed to save MCP server configuration for "${slug}"`,
+					details: `Could not write to ${mcpFilePath}: ${error instanceof Error ? error.message : String(error)}`,
+				};
+			}
+		}
+
+		return {
+			success: true,
+			message: "MCP configuration files written successfully",
+			data: {
+				mcpFilesWritten,
+				serversConfigured: serverSlugs,
+			},
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: "MCP server configuration failed",
+			details: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+/**
+ * Perform environment variable substitution on a config object
+ * Replaces ${VAR_NAME} placeholders with values from the env map
+ */
+function performEnvSubstitution(config: any): any {
+	if (!config) return config;
+
+	// Get environment variables from the config
+	const env = config.env || {};
+
+	// Deep clone the config to avoid mutations
+	const processed = JSON.parse(JSON.stringify(config));
+
+	// Recursively process all string values
+	function processValue(value: any): any {
+		if (typeof value === "string") {
+			// Replace ${VAR_NAME} with the actual value from env
+			return value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+				return env[varName] || match;
+			});
+		}
+
+		if (Array.isArray(value)) {
+			return value.map(processValue);
+		}
+
+		if (typeof value === "object" && value !== null) {
+			const result: any = {};
+			for (const key of Object.keys(value)) {
+				result[key] = processValue(value[key]);
+			}
+			return result;
+		}
+
+		return value;
+	}
+
+	return processValue(processed);
+}

package/src/handlers/cyrusConfig.ts

@@ -0,0 +1,185 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { ApiResponse, CyrusConfigPayload } from "../types.js";
+
+/**
+ * Handle Cyrus configuration update
+ * Updates the ~/.cyrus/config.json file with the provided configuration
+ */
+export async function handleCyrusConfig(
+	payload: CyrusConfigPayload,
+	cyrusHome: string,
+): Promise<ApiResponse> {
+	try {
+		// Validate payload
+		if (!payload.repositories || !Array.isArray(payload.repositories)) {
+			return {
+				success: false,
+				error: "Configuration update requires repositories array",
+				details:
+					"The repositories field must be provided as an array, even if empty.",
+			};
+		}
+
+		// Validate each repository has required fields
+		for (const repo of payload.repositories) {
+			if (!repo.id || !repo.name || !repo.repositoryPath || !repo.baseBranch) {
+				const missingFields: string[] = [];
+				if (!repo.id) missingFields.push("id");
+				if (!repo.name) missingFields.push("name");
+				if (!repo.repositoryPath) missingFields.push("repositoryPath");
+				if (!repo.baseBranch) missingFields.push("baseBranch");
+
+				return {
+					success: false,
+					error: "Repository configuration is incomplete",
+					details: `Repository "${repo.name || "unknown"}" is missing required fields: ${missingFields.join(", ")}`,
+				};
+			}
+		}
+
+		const configPath = join(cyrusHome, "config.json");
+
+		// Ensure the .cyrus directory exists
+		const configDir = dirname(configPath);
+		if (!existsSync(configDir)) {
+			mkdirSync(configDir, { recursive: true });
+		}
+
+		// Build the config object with repositories and optional settings
+		const repositories = payload.repositories.map((repo) => {
+			const repoConfig: any = {
+				id: repo.id,
+				name: repo.name,
+				repositoryPath: repo.repositoryPath,
+				baseBranch: repo.baseBranch,
+			};
+
+			// Add optional Linear fields
+			if (repo.linearWorkspaceId) {
+				repoConfig.linearWorkspaceId = repo.linearWorkspaceId;
+			}
+			if (repo.linearToken) {
+				repoConfig.linearToken = repo.linearToken;
+			}
+
+			// Set workspaceBaseDir (use provided or default to ~/.cyrus/workspaces)
+			repoConfig.workspaceBaseDir =
+				repo.workspaceBaseDir || join(cyrusHome, "workspaces");
+
+			// Set isActive (defaults to true)
+			repoConfig.isActive = repo.isActive !== false;
+
+			// Optional arrays and objects
+			if (repo.allowedTools && repo.allowedTools.length > 0) {
+				repoConfig.allowedTools = repo.allowedTools;
+			}
+
+			if (repo.mcpConfigPath && repo.mcpConfigPath.length > 0) {
+				repoConfig.mcpConfigPath = repo.mcpConfigPath;
+			}
+
+			if (repo.teamKeys) {
+				repoConfig.teamKeys = repo.teamKeys;
+			} else {
+				repoConfig.teamKeys = [];
+			}
+
+			if (repo.labelPrompts && Object.keys(repo.labelPrompts).length > 0) {
+				repoConfig.labelPrompts = repo.labelPrompts;
+			}
+
+			return repoConfig;
+		});
+
+		// Build complete config
+		const config: any = {
+			repositories,
+		};
+
+		// Add optional global settings
+		if (payload.disallowedTools && payload.disallowedTools.length > 0) {
+			config.disallowedTools = payload.disallowedTools;
+		}
+
+		if (payload.ngrokAuthToken) {
+			config.ngrokAuthToken = payload.ngrokAuthToken;
+		}
+
+		if (payload.stripeCustomerId) {
+			config.stripeCustomerId = payload.stripeCustomerId;
+		}
+
+		if (payload.defaultModel) {
+			config.defaultModel = payload.defaultModel;
+		}
+
+		if (payload.defaultFallbackModel) {
+			config.defaultFallbackModel = payload.defaultFallbackModel;
+		}
+
+		if (payload.global_setup_script) {
+			config.global_setup_script = payload.global_setup_script;
+		}
+
+		// Backup existing config if requested
+		if (payload.backupConfig && existsSync(configPath)) {
+			try {
+				const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+				const backupPath = join(cyrusHome, `config.backup-${timestamp}.json`);
+				const existingConfig = readFileSync(configPath, "utf-8");
+				writeFileSync(backupPath, existingConfig, "utf-8");
+			} catch (backupError) {
+				// Log but don't fail - backup is not critical
+				console.warn(
+					`Failed to backup config: ${backupError instanceof Error ? backupError.message : String(backupError)}`,
+				);
+			}
+		}
+
+		// Write config file
+		try {
+			writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+
+			return {
+				success: true,
+				message: "Cyrus configuration updated successfully",
+				data: {
+					configPath,
+					repositoriesCount: repositories.length,
+					restartCyrus: payload.restartCyrus || false,
+				},
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: "Failed to save configuration file",
+				details: `Could not write configuration to ${configPath}: ${error instanceof Error ? error.message : String(error)}`,
+			};
+		}
+	} catch (error) {
+		return {
+			success: false,
+			error: "Configuration update failed",
+			details: error instanceof Error ? error.message : String(error),
+		};
+	}
+}
+
+/**
+ * Read current Cyrus configuration
+ */
+export function readCyrusConfig(cyrusHome: string): any {
+	const configPath = join(cyrusHome, "config.json");
+
+	if (!existsSync(configPath)) {
+		return { repositories: [] };
+	}
+
+	try {
+		const data = readFileSync(configPath, "utf-8");
+		return JSON.parse(data);
+	} catch {
+		return { repositories: [] };
+	}
+}

package/src/handlers/cyrusEnv.ts

@@ -0,0 +1,132 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { ApiResponse, CyrusEnvPayload } from "../types.js";
+
+/**
+ * Handle Cyrus environment variables update
+ * Primarily used to update/provide the Claude API token
+ */
+export async function handleCyrusEnv(
+	payload: CyrusEnvPayload,
+	cyrusHome: string,
+): Promise<ApiResponse> {
+	try {
+		// Validate payload
+		if (!payload || typeof payload !== "object") {
+			return {
+				success: false,
+				error: "Environment variables update requires valid data",
+				details:
+					"Payload must be an object containing environment variable key-value pairs.",
+			};
+		}
+
+		// Extract environment variables from payload
+		// The payload may have a 'variables' key containing the env vars,
+		// or the env vars may be directly in the payload
+		const envVarsSource = payload.variables || payload;
+		const envVars = Object.entries(envVarsSource).filter(
+			([key, value]) =>
+				value !== undefined &&
+				typeof value === "string" &&
+				!["variables", "restartCyrus", "backupEnv"].includes(key),
+		) as [string, string][];
+
+		if (envVars.length === 0) {
+			return {
+				success: false,
+				error: "No environment variables to update",
+				details:
+					"At least one environment variable must be provided in the request.",
+			};
+		}
+
+		const envPath = join(cyrusHome, ".env");
+
+		// Ensure the .cyrus directory exists
+		const envDir = dirname(envPath);
+		if (!existsSync(envDir)) {
+			mkdirSync(envDir, { recursive: true });
+		}
+
+		// Read existing env file if it exists
+		const existingEnv: Record<string, string> = {};
+		if (existsSync(envPath)) {
+			try {
+				const content = readFileSync(envPath, "utf-8");
+				const lines = content.split("\n");
+
+				for (const line of lines) {
+					const trimmed = line.trim();
+					// Skip empty lines and comments
+					if (!trimmed || trimmed.startsWith("#")) {
+						continue;
+					}
+
+					const equalIndex = trimmed.indexOf("=");
+					if (equalIndex > 0) {
+						const key = trimmed.substring(0, equalIndex);
+						const value = trimmed.substring(equalIndex + 1);
+						existingEnv[key] = value;
+					}
+				}
+			} catch {
+				// Ignore errors reading existing file - we'll create a new one
+			}
+		}
+
+		// Merge new variables (new values override existing ones)
+		for (const [key, value] of envVars) {
+			if (value !== undefined) {
+				existingEnv[key] = value;
+			}
+		}
+
+		// Build new env file content
+		const envContent = Object.entries(existingEnv)
+			.map(([key, value]) => `${key}=${value}`)
+			.join("\n");
+
+		// Backup existing env file if requested
+		if (payload.backupEnv && existsSync(envPath)) {
+			try {
+				const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+				const backupPath = join(cyrusHome, `.env.backup-${timestamp}`);
+				const existingEnvFile = readFileSync(envPath, "utf-8");
+				writeFileSync(backupPath, existingEnvFile, "utf-8");
+			} catch (backupError) {
+				// Log but don't fail - backup is not critical
+				console.warn(
+					`Failed to backup env: ${backupError instanceof Error ? backupError.message : String(backupError)}`,
+				);
+			}
+		}
+
+		// Write env file
+		try {
+			writeFileSync(envPath, `${envContent}\n`, "utf-8");
+
+			return {
+				success: true,
+				message: "Environment variables updated successfully",
+				data: {
+					envPath,
+					variablesUpdated: envVars.map(([key]) => key),
+					restartCyrus: payload.restartCyrus || false,
+				},
+			};
+		} catch (error) {
+			return {
+				success: false,
+				error: "Failed to save environment variables",
+				details: `Could not write to ${envPath}: ${error instanceof Error ? error.message : String(error)}`,
+			};
+		}
+	} catch (error) {
+		return {
+			success: false,
+			error: "Environment variables update failed",
+			details: error instanceof Error ? error.message : String(error),
+		};
+	}
+}