cyrus-config-updater 0.2.0-rc → 0.2.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyrus-config-updater",
-  "version": "0.2.0-rc",
+  "version": "0.2.0-rc.1",
   "description": "Configuration update handlers for Cyrus agent",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,6 +11,9 @@
       "import": "./dist/index.js"
     }
   },
+  "files": [
+    "dist"
+  ],
   "dependencies": {
     "fastify": "^5.2.0"
   },

package/src/ConfigUpdater.ts

@@ -1,156 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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),
-		};
-	}
-}

package/src/handlers/repository.ts

@@ -1,137 +0,0 @@
-import { exec } from "node:child_process";
-import { existsSync, mkdirSync } from "node:fs";
-import { basename, join } from "node:path";
-import { promisify } from "node:util";
-import type { ApiResponse, RepositoryPayload } from "../types.js";
-
-const execAsync = promisify(exec);
-
-/**
- * Check if a directory contains a git repository
- */
-function isGitRepository(path: string): boolean {
-	try {
-		return existsSync(join(path, ".git"));
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Extract repository name from URL
- */
-function getRepoNameFromUrl(repoUrl: string): string {
-	// Handle URLs like: https://github.com/user/repo.git or git@github.com:user/repo.git
-	const match = repoUrl.match(/\/([^/]+?)(\.git)?$/);
-	if (match?.[1]) {
-		return match[1];
-	}
-	// Fallback: use last part of URL
-	return basename(repoUrl, ".git");
-}
-
-/**
- * Handle repository cloning or verification
- * - Clones repositories to ~/.cyrus/repos/<repo-name> using GitHub CLI (gh)
- * - If repository exists, verify it's a git repo and do nothing
- * - If repository doesn't exist, clone it to ~/.cyrus/repos/<repo-name>
- */
-export async function handleRepository(
-	payload: RepositoryPayload,
-	cyrusHome: string,
-): Promise<ApiResponse> {
-	try {
-		// Validate payload
-		if (!payload.repository_url || typeof payload.repository_url !== "string") {
-			return {
-				success: false,
-				error: "Repository URL is required",
-				details:
-					"Please provide a valid Git repository URL (e.g., https://github.com/user/repo.git)",
-			};
-		}
-
-		// Use repository name from payload or extract from URL
-		const repoName =
-			payload.repository_name || getRepoNameFromUrl(payload.repository_url);
-
-		// Construct path within ~/.cyrus/repos
-		const reposDir = join(cyrusHome, "repos");
-		const repoPath = join(reposDir, repoName);
-
-		// Ensure repos directory exists
-		if (!existsSync(reposDir)) {
-			try {
-				mkdirSync(reposDir, { recursive: true });
-			} catch (error) {
-				return {
-					success: false,
-					error: "Failed to create repositories directory",
-					details: `Could not create directory at ${reposDir}: ${error instanceof Error ? error.message : String(error)}`,
-				};
-			}
-		}
-
-		// Check if repository already exists
-		if (existsSync(repoPath)) {
-			// Verify it's a git repository
-			if (isGitRepository(repoPath)) {
-				return {
-					success: true,
-					message: "Repository already exists",
-					data: {
-						path: repoPath,
-						name: repoName,
-						action: "verified",
-					},
-				};
-			}
-
-			return {
-				success: false,
-				error: "Directory exists but is not a Git repository",
-				details: `A non-Git directory already exists at ${repoPath}. Please remove it manually or choose a different repository name.`,
-			};
-		}
-
-		// Clone the repository using gh
-		try {
-			const cloneCmd = `gh repo clone "${payload.repository_url}" "${repoPath}"`;
-			await execAsync(cloneCmd);
-
-			// Verify the clone was successful
-			if (!isGitRepository(repoPath)) {
-				return {
-					success: false,
-					error: "Repository clone verification failed",
-					details: `GitHub CLI clone command completed, but the cloned directory at ${repoPath} does not appear to be a valid Git repository.`,
-				};
-			}
-
-			return {
-				success: true,
-				message: "Repository cloned successfully",
-				data: {
-					path: repoPath,
-					name: repoName,
-					repository_url: payload.repository_url,
-					action: "cloned",
-				},
-			};
-		} catch (error) {
-			const errorMessage =
-				error instanceof Error ? error.message : String(error);
-			return {
-				success: false,
-				error: "Failed to clone repository",
-				details: `Could not clone repository from ${payload.repository_url} using GitHub CLI: ${errorMessage}. Please verify the URL is correct, you have access to the repository, and gh is authenticated.`,
-			};
-		}
-	} catch (error) {
-		return {
-			success: false,
-			error: "Repository operation failed",
-			details: error instanceof Error ? error.message : String(error),
-		};
-	}
-}

package/src/handlers/testMcp.ts

@@ -1,82 +0,0 @@
-import type { ApiResponse, TestMcpPayload } from "../types.js";
-
-/**
- * Handle MCP connection test
- * Tests connectivity and configuration of an MCP server
- *
- * Note: This is a placeholder implementation. The actual MCP testing logic
- * would require integrating with the MCP SDK to test connections.
- */
-export async function handleTestMcp(
-	payload: TestMcpPayload,
-): Promise<ApiResponse> {
-	try {
-		// Validate payload
-		if (!payload.transportType) {
-			return {
-				success: false,
-				error: "MCP test requires transport type",
-				details:
-					'The transportType field is required and must be either "stdio" or "sse".',
-			};
-		}
-
-		if (payload.transportType !== "stdio" && payload.transportType !== "sse") {
-			return {
-				success: false,
-				error: "Invalid MCP transport type",
-				details: `Transport type "${payload.transportType}" is not supported. Must be either "stdio" or "sse".`,
-			};
-		}
-
-		// Validate transport-specific requirements
-		if (payload.transportType === "stdio") {
-			if (!payload.command) {
-				return {
-					success: false,
-					error: "MCP stdio transport requires command",
-					details:
-						"The command field is required when using stdio transport type.",
-				};
-			}
-		} else if (payload.transportType === "sse") {
-			if (!payload.serverUrl) {
-				return {
-					success: false,
-					error: "MCP SSE transport requires server URL",
-					details:
-						"The serverUrl field is required when using SSE transport type.",
-				};
-			}
-		}
-
-		// TODO: Implement actual MCP connection testing
-		// This would involve:
-		// 1. Creating an MCP client with the provided configuration
-		// 2. Attempting to connect to the MCP server
-		// 3. Listing available tools/resources
-		// 4. Getting server info
-		// 5. Returning the results
-
-		return {
-			success: true,
-			message: "MCP connection test completed (placeholder implementation)",
-			data: {
-				transportType: payload.transportType,
-				tools: [],
-				serverInfo: {
-					name: "placeholder",
-					version: "0.0.0",
-					protocol: "mcp/1.0",
-				},
-				note: "This is a placeholder response. Full MCP testing will be implemented in a future update.",
-			},
-		};
-	} catch (error) {
-		return {
-			success: false,
-			error: "MCP connection test failed",
-			details: error instanceof Error ? error.message : String(error),
-		};
-	}
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export { ConfigUpdater } from "./ConfigUpdater.js";
-export * from "./types.js";

package/src/types.ts

@@ -1,111 +0,0 @@
-/**
- * Repository configuration payload
- * Matches the format sent by cyrus-hosted
- */
-export interface RepositoryPayload {
-	repository_url: string; // Git clone URL
-	repository_name: string; // Repository name (required)
-}
-
-/**
- * Cyrus config update payload
- */
-export interface CyrusConfigPayload {
-	repositories: Array<{
-		id: string;
-		name: string;
-		repositoryPath: string;
-		baseBranch: string;
-		linearWorkspaceId?: string;
-		linearToken?: string;
-		workspaceBaseDir?: string;
-		isActive?: boolean;
-		allowedTools?: string[];
-		mcpConfigPath?: string[];
-		teamKeys?: string[];
-		labelPrompts?: Record<string, string[]>;
-	}>;
-	disallowedTools?: string[];
-	ngrokAuthToken?: string;
-	stripeCustomerId?: string;
-	defaultModel?: string;
-	defaultFallbackModel?: string;
-	global_setup_script?: string;
-	restartCyrus?: boolean;
-	backupConfig?: boolean;
-}
-
-/**
- * Cyrus environment variables payload (for Claude token)
- */
-export interface CyrusEnvPayload {
-	variables?: Record<string, string>;
-	ANTHROPIC_API_KEY?: string;
-	restartCyrus?: boolean;
-	backupEnv?: boolean;
-	[key: string]: string | boolean | Record<string, string> | undefined;
-}
-
-/**
- * MCP server configuration
- */
-export interface McpServerConfig {
-	command?: string;
-	args?: string[];
-	env?: Record<string, string>;
-	url?: string;
-	transport?: "stdio" | "sse";
-	headers?: Record<string, string>;
-}
-
-/**
- * Test MCP connection payload
- */
-export interface TestMcpPayload {
-	transportType: "stdio" | "sse";
-	serverUrl?: string | null;
-	command?: string | null;
-	commandArgs?: Array<{ value: string; order: number }> | null;
-	headers?: Array<{ name: string; value: string }> | null;
-	envVars?: Array<{ key: string; value: string }> | null;
-}
-
-/**
- * Configure MCP servers payload
- */
-export interface ConfigureMcpPayload {
-	mcpServers: Record<string, McpServerConfig>;
-}
-
-/**
- * Check GitHub CLI payload (empty - no parameters needed)
- */
-export type CheckGhPayload = Record<string, never>;
-
-/**
- * Check GitHub CLI response data
- */
-export interface CheckGhData {
-	isInstalled: boolean;
-	isAuthenticated: boolean;
-}
-
-/**
- * Error response to send back to cyrus-hosted
- */
-export interface ErrorResponse {
-	success: false;
-	error: string;
-	details?: string;
-}
-
-/**
- * Success response to send back to cyrus-hosted
- */
-export interface SuccessResponse {
-	success: true;
-	message: string;
-	data?: any;
-}
-
-export type ApiResponse = SuccessResponse | ErrorResponse;

package/test/handlers/checkGh.test.ts

@@ -1,144 +0,0 @@
-import { exec } from "node:child_process";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { handleCheckGh } from "../../src/handlers/checkGh.js";
-import type { CheckGhPayload } from "../../src/types.js";
-
-// Mock node:child_process
-vi.mock("node:child_process", () => ({
-	exec: vi.fn(),
-}));
-
-// Mock node:util (promisify is used in the handler)
-vi.mock("node:util", () => ({
-	promisify: (fn: any) => fn,
-}));
-
-describe("handleCheckGh", () => {
-	const mockExec = vi.mocked(exec);
-	const cyrusHome = "/test/cyrus/home";
-	const payload: CheckGhPayload = {};
-
-	beforeEach(() => {
-		vi.clearAllMocks();
-	});
-
-	afterEach(() => {
-		vi.resetAllMocks();
-	});
-
-	describe("when gh is installed and authenticated", () => {
-		it("should return success with both flags true", async () => {
-			// Mock successful gh --version call
-			mockExec.mockImplementation((cmd: string, _callback?: any) => {
-				if (cmd === "gh --version") {
-					return Promise.resolve({ stdout: "gh version 2.0.0", stderr: "" });
-				}
-				if (cmd === "gh auth status") {
-					return Promise.resolve({
-						stdout: "Logged in to github.com",
-						stderr: "",
-					});
-				}
-				return Promise.reject(new Error("Unknown command"));
-			});
-
-			const result = await handleCheckGh(payload, cyrusHome);
-
-			expect(result).toEqual({
-				success: true,
-				message: "GitHub CLI check completed",
-				data: {
-					isInstalled: true,
-					isAuthenticated: true,
-				},
-			});
-		});
-	});
-
-	describe("when gh is installed but not authenticated", () => {
-		it("should return success with isInstalled true and isAuthenticated false", async () => {
-			mockExec.mockImplementation((cmd: string, _callback?: any) => {
-				if (cmd === "gh --version") {
-					return Promise.resolve({ stdout: "gh version 2.0.0", stderr: "" });
-				}
-				if (cmd === "gh auth status") {
-					return Promise.reject(new Error("Not authenticated"));
-				}
-				return Promise.reject(new Error("Unknown command"));
-			});
-
-			const result = await handleCheckGh(payload, cyrusHome);
-
-			expect(result).toEqual({
-				success: true,
-				message: "GitHub CLI check completed",
-				data: {
-					isInstalled: true,
-					isAuthenticated: false,
-				},
-			});
-		});
-	});
-
-	describe("when gh is not installed", () => {
-		it("should return success with both flags false", async () => {
-			mockExec.mockImplementation((cmd: string, _callback?: any) => {
-				if (cmd === "gh --version") {
-					return Promise.reject(new Error("command not found: gh"));
-				}
-				return Promise.reject(new Error("Unknown command"));
-			});
-
-			const result = await handleCheckGh(payload, cyrusHome);
-
-			expect(result).toEqual({
-				success: true,
-				message: "GitHub CLI check completed",
-				data: {
-					isInstalled: false,
-					isAuthenticated: false,
-				},
-			});
-		});
-
-		it("should not check authentication when gh is not installed", async () => {
-			mockExec.mockImplementation((cmd: string, _callback?: any) => {
-				if (cmd === "gh --version") {
-					return Promise.reject(new Error("command not found: gh"));
-				}
-				if (cmd === "gh auth status") {
-					throw new Error("Should not be called");
-				}
-				return Promise.reject(new Error("Unknown command"));
-			});
-
-			const result = await handleCheckGh(payload, cyrusHome);
-
-			expect(result.success).toBe(true);
-			expect(result.data).toEqual({
-				isInstalled: false,
-				isAuthenticated: false,
-			});
-		});
-	});
-
-	describe("command execution edge cases", () => {
-		it("should treat any execAsync rejection as command not found", async () => {
-			mockExec.mockImplementation(() => {
-				return Promise.reject(new Error("Permission denied"));
-			});
-
-			const result = await handleCheckGh(payload, cyrusHome);
-
-			// Any error is treated as "not installed"
-			expect(result).toEqual({
-				success: true,
-				message: "GitHub CLI check completed",
-				data: {
-					isInstalled: false,
-					isAuthenticated: false,
-				},
-			});
-		});
-	});
-});

package/test-scripts/test-check-gh.js

@@ -1,56 +0,0 @@
-#!/usr/bin/env node
-/**
- * Manual test script for the /api/check-gh endpoint
- *
- * This script demonstrates how to use the check-gh endpoint to verify
- * whether the GitHub CLI (gh) is installed and authenticated.
- *
- * Usage:
- *   node test-scripts/test-check-gh.js
- *
- * Note: This requires a running EdgeWorker server with ConfigUpdater registered
- * and a valid CYRUS_API_KEY environment variable set.
- */
-
-import { handleCheckGh } from "../dist/handlers/checkGh.js";
-
-async function testCheckGh() {
-	console.log("Testing handleCheckGh handler...\n");
-
-	try {
-		const result = await handleCheckGh({}, "/tmp/test-cyrus-home");
-
-		console.log("Result:", JSON.stringify(result, null, 2));
-
-		if (result.success) {
-			console.log("\n✅ Handler executed successfully");
-			console.log(`   - GitHub CLI installed: ${result.data.isInstalled}`);
-			console.log(
-				`   - GitHub CLI authenticated: ${result.data.isAuthenticated}`,
-			);
-
-			if (!result.data.isInstalled) {
-				console.log("\n💡 To install GitHub CLI:");
-				console.log("   - macOS: brew install gh");
-				console.log(
-					"   - Linux: https://github.com/cli/cli/blob/trunk/docs/install_linux.md",
-				);
-				console.log("   - Windows: https://github.com/cli/cli/releases");
-			} else if (!result.data.isAuthenticated) {
-				console.log("\n💡 To authenticate GitHub CLI:");
-				console.log("   Run: gh auth login");
-			}
-		} else {
-			console.log("\n❌ Handler failed");
-			console.log(`   Error: ${result.error}`);
-			if (result.details) {
-				console.log(`   Details: ${result.details}`);
-			}
-		}
-	} catch (error) {
-		console.error("❌ Unexpected error:", error);
-		process.exit(1);
-	}
-}
-
-testCheckGh();

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-	"extends": "../../tsconfig.base.json",
-	"compilerOptions": {
-		"outDir": "./dist",
-		"rootDir": "./src",
-		"declaration": true,
-		"declarationMap": true,
-		"sourceMap": true
-	},
-	"include": ["src/**/*"],
-	"exclude": ["node_modules", "dist", "test"]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-	test: {
-		globals: true,
-		environment: "node",
-	},
-});