cyrus-config-updater 0.2.0-rc

package/src/handlers/repository.ts

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

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

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

package/src/types.ts

@@ -0,0 +1,111 @@
+/**
+ * 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

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

@@ -0,0 +1,56 @@
+#!/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

@@ -0,0 +1,12 @@
+{
+	"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

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