@mks2508/coolify-mks-cli-mcp 0.6.3 → 0.8.0

package/dist/index.cjs

@@ -5784,8 +5784,8 @@ var CoolifyService = class {
 			environment_uuid: options.environmentUuid,
 			server_uuid: options.serverUuid
 		};
+		if (options.githubRepoUrl) body.git_repository = options.githubRepoUrl.replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
 		if (appType === "public" || appType === "private-github-app" || appType === "private-deploy-key") {
-			if (options.githubRepoUrl) body.git_repository = options.githubRepoUrl.replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
 			if (options.githubAppUuid) body.github_app_uuid = options.githubAppUuid;
 			body.git_branch = options.branch || "main";
 			body.build_pack = options.buildPack || "dockerfile";
@@ -5827,7 +5827,8 @@ var CoolifyService = class {
 				body: JSON.stringify({
 					key,
 					value,
-					is_preview: false
+					is_preview: false,
+					is_buildtime: false
 				})
 			});
 			if (result.error && result.error.includes("already exists")) {
@@ -5840,7 +5841,8 @@ var CoolifyService = class {
 						body: JSON.stringify({
 							key,
 							value,
-							is_preview: false
+							is_preview: false,
+							is_buildtime: false
 						})
 					});
 					if (repost.error) {
@@ -5886,8 +5888,8 @@ var CoolifyService = class {
 	* @param isBuildTime - Whether the variable is available at build time (only for new vars)
 	* @returns Result indicating success or error
 	*/
-	async setEnvironmentVariable(appUuid, key, value, _isBuildTime = false) {
-		log.info(`Setting environment variable ${key} for ${appUuid}`);
+	async setEnvironmentVariable(appUuid, key, value, isBuildTime = false) {
+		log.info(`Setting environment variable ${key} for ${appUuid} (buildtime: ${isBuildTime})`);
 		const existingVars = await this.getEnvironmentVariables(appUuid);
 		if (isErr(existingVars)) return err(existingVars.error);
 		const exists = existingVars.value.some((ev) => ev.key === key);
@@ -5897,7 +5899,8 @@ var CoolifyService = class {
 				method: "PATCH",
 				body: JSON.stringify({
 					key,
-					value
+					value,
+					is_buildtime: isBuildTime
 				})
 			});
 			if (result.error) {
@@ -5910,7 +5913,8 @@ var CoolifyService = class {
 				method: "POST",
 				body: JSON.stringify({
 					key,
-					value
+					value,
+					is_buildtime: isBuildTime
 				})
 			});
 			if (result.error) {
@@ -6167,6 +6171,15 @@ var CoolifyService = class {
 		if (options.dockerComposeDomains) body.docker_compose_domains = options.dockerComposeDomains;
 		if (options.isForceHttpsEnabled !== void 0) body.is_force_https_enabled = options.isForceHttpsEnabled;
 		if (options.isAutoDeployEnabled !== void 0) body.is_auto_deploy_enabled = options.isAutoDeployEnabled;
+		if (options.healthCheckEnabled !== void 0) body.health_check_enabled = options.healthCheckEnabled;
+		if (options.healthCheckPath) body.health_check_path = options.healthCheckPath;
+		if (options.healthCheckPort) body.health_check_port = String(options.healthCheckPort);
+		if (options.healthCheckMethod) body.health_check_method = options.healthCheckMethod;
+		if (options.healthCheckInterval) body.health_check_interval = options.healthCheckInterval;
+		if (options.healthCheckTimeout) body.health_check_timeout = options.healthCheckTimeout;
+		if (options.healthCheckRetries) body.health_check_retries = options.healthCheckRetries;
+		if (options.healthCheckStartPeriod) body.health_check_start_period = options.healthCheckStartPeriod;
+		if (options.healthCheckReturnCode) body.health_check_return_code = options.healthCheckReturnCode;
 		const result = await this.request(`/applications/${appUuid}`, {
 			method: "PATCH",
 			body: JSON.stringify(body)
@@ -6625,6 +6638,125 @@ var CoolifyService = class {
 		});
 	}
 	/**
+	* Gets the full infrastructure tree: Projects → Environments → Resources.
+	*
+	* Fetches all projects, apps, databases, and services in parallel,
+	* then groups them by environment_id into a hierarchical tree.
+	*
+	* @returns Result with the full infrastructure tree or error
+	*/
+	async getInfrastructureTree() {
+		log.info("Building infrastructure tree");
+		const [projectsResult, appsResult, dbsResult, svcsResult, serversResult] = await Promise.all([
+			this.listProjects(),
+			this.listApplications(),
+			this.listDatabases(),
+			this.listServices(),
+			this.listServers()
+		]);
+		if (isErr(projectsResult)) return err(projectsResult.error);
+		if (isErr(appsResult)) return err(appsResult.error);
+		if (isErr(serversResult)) return err(serversResult.error);
+		const projects = projectsResult.value;
+		const apps = appsResult.value;
+		const dbs = isErr(dbsResult) ? [] : dbsResult.value;
+		const svcs = isErr(svcsResult) ? [] : svcsResult.value;
+		const servers = serversResult.value;
+		const envResults = await Promise.allSettled(projects.map((p) => this.getProjectEnvironments(p.uuid)));
+		const envIdMap = new Map();
+		for (let i = 0; i < projects.length; i++) {
+			const envResult = envResults[i];
+			if (envResult.status === "fulfilled" && !isErr(envResult.value)) for (const env of envResult.value.value) envIdMap.set(env.id, {
+				projectUuid: projects[i].uuid,
+				envName: env.name,
+				envUuid: env.uuid
+			});
+		}
+		const projectNodes = projects.map((p) => ({
+			uuid: p.uuid,
+			name: p.name,
+			description: p.description,
+			environments: []
+		}));
+		const projectMap = new Map();
+		for (const node of projectNodes) projectMap.set(node.uuid, node);
+		const envNodeMap = new Map();
+		for (const [envId, info] of envIdMap) {
+			const project = projectMap.get(info.projectUuid);
+			if (!project) continue;
+			let envNode = project.environments.find((e) => e.id === envId);
+			if (!envNode) {
+				envNode = {
+					id: envId,
+					uuid: info.envUuid,
+					name: info.envName,
+					resources: []
+				};
+				project.environments.push(envNode);
+			}
+			envNodeMap.set(envId, envNode);
+		}
+		for (const app of apps) {
+			const envNode = app.environment_id ? envNodeMap.get(app.environment_id) : void 0;
+			const resource = {
+				uuid: app.uuid,
+				name: app.name,
+				kind: "app",
+				status: app.status,
+				fqdn: app.fqdn
+			};
+			if (envNode) envNode.resources.push(resource);
+		}
+		for (const db of dbs) {
+			const envNode = db.environment_id ? envNodeMap.get(db.environment_id) : void 0;
+			const resource = {
+				uuid: db.uuid,
+				name: db.name,
+				kind: "database",
+				status: db.status,
+				dbType: db.type
+			};
+			if (envNode) envNode.resources.push(resource);
+		}
+		for (const svc of svcs) {
+			const envNode = svc.environment_id ? envNodeMap.get(svc.environment_id) : void 0;
+			const resource = {
+				uuid: svc.uuid,
+				name: svc.name,
+				kind: "service",
+				status: svc.status
+			};
+			if (envNode) envNode.resources.push(resource);
+		}
+		const populatedProjects = projectNodes.filter((p) => p.environments.some((e) => e.resources.length > 0));
+		const allStatuses = [
+			...apps.map((a) => a.status),
+			...dbs.map((d) => d.status),
+			...svcs.map((s) => s.status)
+		];
+		const counts = {
+			projects: populatedProjects.length,
+			apps: apps.length,
+			databases: dbs.length,
+			services: svcs.length,
+			healthy: allStatuses.filter((s) => s.includes("healthy")).length,
+			running: allStatuses.filter((s) => s.startsWith("running") && !s.includes("healthy")).length,
+			stopped: allStatuses.filter((s) => s.includes("exited")).length,
+			unhealthy: allStatuses.filter((s) => s.includes("unhealthy")).length
+		};
+		const server = servers[0] || { name: "Unknown" };
+		log.success(`Infrastructure tree built: ${counts.projects} projects, ${counts.apps} apps, ${counts.databases} dbs, ${counts.services} svcs`);
+		return ok({
+			server: {
+				name: server.name,
+				ip: server.ip,
+				uuid: server.uuid
+			},
+			projects: populatedProjects,
+			counts
+		});
+	}
+	/**
 	* Starts a service.
 	* Note: Coolify API uses GET for service start/stop/restart.
 	*
@@ -7063,6 +7195,22 @@ var CoolifyService = class {
 		return ok(deployments);
 	}
 	/**
+	* Gets full application details by UUID.
+	*
+	* Makes a direct GET request to /api/v1/applications/{uuid} which returns
+	* complete application data including project_uuid and environment_uuid.
+	*
+	* @param appUuid - Application UUID
+	* @returns Result with full application details or error
+	*/
+	async getApplication(appUuid) {
+		log.info(`Getting application details: ${appUuid}`);
+		const result = await this.request(`/applications/${appUuid}`);
+		if (result.error) return err(new Error(result.error));
+		if (!result.data) return err(new Error("Application not found"));
+		return ok(result.data);
+	}
+	/**
 	* Resolves an application by UUID, name, or domain (FQDN).
 	*
 	* @param query - UUID, name, or domain to search for
@@ -7455,6 +7603,117 @@ var ApplicationsResource = class {
 	async deleteEnv(uuid, key) {
 		return unwrap(await this.svc.deleteEnvironmentVariable(uuid, key));
 	}
+	/**
+	* Sync environment variables from a local .env file to Coolify.
+	*
+	* @param uuid - Application UUID
+	* @param options - Sync options
+	* @returns Sync result with changes applied
+	*/
+	async syncEnv(uuid, options = {}) {
+		const { filePath, dryRun = false, prune = false, onProgress } = options;
+		let envContent;
+		try {
+			envContent = await Bun.file(filePath || ".env").text();
+		} catch {
+			throw new Error(filePath ? `Cannot read file: ${filePath}` : "No .env file found in current directory");
+		}
+		const localVars = this.parseEnvContent(envContent);
+		if (localVars.size === 0) return {
+			added: [],
+			updated: [],
+			removed: [],
+			skipped: 0
+		};
+		const currentVarsList = await this.envVars(uuid);
+		const currentVars = new Map(currentVarsList.map((v) => [v.key, v.value]));
+		const toAdd = [];
+		const toUpdate = [];
+		const toRemove = [];
+		for (const [key, value] of localVars.entries()) {
+			const currentValue = currentVars.get(key);
+			if (!currentValue) toAdd.push({
+				key,
+				value
+			});
+			else if (currentValue !== value) toUpdate.push({
+				key,
+				value,
+				oldValue: currentValue
+			});
+		}
+		if (prune) {
+			for (const key of currentVars.keys()) if (!localVars.has(key)) toRemove.push(key);
+		}
+		if (!dryRun) {
+			for (const { key, value } of toAdd) {
+				await this.setEnv(uuid, key, value, false);
+				onProgress?.({
+					type: "add",
+					key,
+					value
+				});
+			}
+			for (const { key, value } of toUpdate) {
+				await this.setEnv(uuid, key, value, false);
+				onProgress?.({
+					type: "update",
+					key,
+					value
+				});
+			}
+			for (const key of toRemove) {
+				await this.deleteEnv(uuid, key);
+				onProgress?.({
+					type: "remove",
+					key
+				});
+			}
+		} else {
+			for (const { key, value } of toAdd) onProgress?.({
+				type: "add",
+				key,
+				value
+			});
+			for (const { key, value } of toUpdate) onProgress?.({
+				type: "update",
+				key,
+				value
+			});
+			for (const key of toRemove) onProgress?.({
+				type: "remove",
+				key
+			});
+		}
+		return {
+			added: toAdd,
+			updated: toUpdate,
+			removed: toRemove,
+			skipped: currentVars.size - toUpdate.length - toRemove.length
+		};
+	}
+	/**
+	* Parse .env file content into a Map.
+	* Handles comments, empty lines, and quoted values.
+	*
+	* @param content - The .env file content
+	* @returns Map of environment variables
+	*/
+	parseEnvContent(content) {
+		const envVars = new Map();
+		const lines = content.split("\n");
+		for (const line of lines) {
+			const trimmedLine = line.trim();
+			if (!trimmedLine || trimmedLine.startsWith("#")) continue;
+			const eqIndex = trimmedLine.indexOf("=");
+			if (eqIndex === -1) continue;
+			const key = trimmedLine.slice(0, eqIndex).trim();
+			let value = trimmedLine.slice(eqIndex + 1).trim();
+			if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+			envVars.set(key, value);
+		}
+		return envVars;
+	}
 };
 var DatabasesResource = class {
 	constructor(svc) {
@@ -9326,7 +9585,10 @@ var init_network = __esm({ "src/network.ts"() {
 //#region src/cli/coolify-state.ts
 const STATE_FILE = ".coolify.json";
 /**
-* Loads .coolify.json from the current working directory.
+* Loads .coolify.json from the current working directory (single-app format).
+*
+* Handles both single-app and multi-app formats. For multi-app state with
+* exactly one app, returns a synthesized single-app state for backward compat.
 *
 * @returns The deploy state if found, null otherwise
 */
@@ -9336,6 +9598,27 @@ function loadCoolifyState() {
 	try {
 		const content = (0, node_fs.readFileSync)(statePath, "utf-8");
 		const state = JSON.parse(content);
+		if (Array.isArray(state.apps)) {
+			if (state.apps.length === 1) {
+				const app = state.apps[0];
+				return {
+					appUuid: app.uuid,
+					appName: app.name,
+					serverUuid: state.serverUuid,
+					serverName: state.serverName,
+					projectUuid: state.projectUuid,
+					projectName: state.projectName,
+					environmentUuid: state.environmentUuid,
+					environmentName: state.environmentName,
+					domain: app.domain,
+					branch: state.branch,
+					gitRepository: state.gitRepository,
+					coolifyUrl: state.coolifyUrl,
+					updatedAt: state.updatedAt
+				};
+			}
+			return null;
+		}
 		if (!state.appUuid) return null;
 		return state;
 	} catch {
@@ -9343,18 +9626,45 @@ function loadCoolifyState() {
 	}
 }
 /**
+* Loads .coolify.json in multi-app format.
+*
+* If the file is in single-app format, returns null (use loadCoolifyState instead).
+*
+* @returns The multi-app state if found, null otherwise
+*/
+function loadMultiAppState() {
+	const statePath = (0, node_path.join)(process.cwd(), STATE_FILE);
+	if (!(0, node_fs.existsSync)(statePath)) return null;
+	try {
+		const content = (0, node_fs.readFileSync)(statePath, "utf-8");
+		const state = JSON.parse(content);
+		if (!Array.isArray(state.apps)) return null;
+		return state;
+	} catch {
+		return null;
+	}
+}
+/**
 * Resolves a UUID argument — if not provided, tries to read from .coolify.json.
 *
+* Supports both single-app and multi-app state formats. For multi-app state
+* with exactly one app, auto-selects that app. For multiple apps, returns null
+* (user must specify explicitly).
+*
 * @param uuid - UUID from CLI argument (may be undefined)
 * @param field - Which field to read from .coolify.json (default: appUuid)
 * @returns The resolved UUID or null if not found
 */
 function resolveUuid(uuid, field = "appUuid") {
-	if (uuid) return uuid;
+	if (uuid && /^[a-z0-9]{16,40}$/.test(uuid)) return uuid;
 	const state = loadCoolifyState();
-	if (!state) return null;
-	const value = state[field];
-	return typeof value === "string" ? value : null;
+	if (state) {
+		const value = state[field];
+		return typeof value === "string" ? value : null;
+	}
+	const multiState = loadMultiAppState();
+	if (multiState && multiState.apps.length === 1 && field === "appUuid") return multiState.apps[0].uuid;
+	return null;
 }
 
 //#endregion