@geode/opengeodeweb-front 10.34.0-rc.1 → 10.34.0-rc.11

package/.build/opengeodeweb_front_schemas.js

@@ -0,0 +1,175 @@
+//#region opengeodeweb_front_schemas.json
+var api = {
+	"cloud": { "extensions": { "run": {
+		"$id": "api/cloud/extensions/run",
+		"route": "/run",
+		"methods": ["POST"],
+		"type": "object",
+		"properties": {
+			"projectFolderPath": { "type": "string" },
+			"projectName": { "type": "string" }
+		},
+		"required": ["projectFolderPath", "projectName"],
+		"additionalProperties": false
+	} } },
+	"local": {
+		"app": {
+			"run_viewer": {
+				"$id": "api/local/app/run_viewer",
+				"route": "/run_viewer",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": {
+					"COMMAND_VIEWER": { "type": "string" },
+					"NUXT_ROOT_PATH": { "type": "string" }
+				},
+				"required": ["COMMAND_VIEWER", "NUXT_ROOT_PATH"],
+				"additionalProperties": true
+			},
+			"run_back": {
+				"$id": "api/local/app/run_back",
+				"route": "/run_back",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": {
+					"COMMAND_BACK": { "type": "string" },
+					"NUXT_ROOT_PATH": { "type": "string" }
+				},
+				"required": ["COMMAND_BACK", "NUXT_ROOT_PATH"],
+				"additionalProperties": true
+			},
+			"project_folder_path": {
+				"$id": "api/local/app/project_folder_path",
+				"route": "/project_folder_path",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": { "PROJECT": { "type": "string" } },
+				"required": ["PROJECT"],
+				"additionalProperties": true
+			},
+			"kill": {
+				"$id": "api/local/app/kill",
+				"route": "/kill",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": {},
+				"required": [],
+				"additionalProperties": false
+			}
+		},
+		"extensions": {
+			"upload": {
+				"$id": "api/local/extensions/upload",
+				"route": "/upload",
+				"methods": ["OPTIONS", "PUT"],
+				"type": "object",
+				"properties": { "filename": {
+					"type": "string",
+					"minLength": 1
+				} },
+				"additionalProperties": false
+			},
+			"run": {
+				"$id": "api/local/extensions/run",
+				"route": "/run",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": {
+					"projectFolderPath": { "type": "string" },
+					"projectName": { "type": "string" }
+				},
+				"required": ["projectFolderPath", "projectName"],
+				"additionalProperties": false
+			},
+			"kill": {
+				"$id": "api/local/extensions/kill",
+				"route": "/kill",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": {
+					"extensionId": { "type": "string" },
+					"projectFolderPath": { "type": "string" },
+					"projectName": { "type": "string" }
+				},
+				"required": [
+					"extensionId",
+					"projectFolderPath",
+					"projectName"
+				],
+				"additionalProperties": false
+			}
+		}
+	},
+	"microservice": {
+		"app": {
+			"set_viewer_base_url": {
+				"$id": "api/microservice/app/set_viewer_base_url",
+				"route": "/set_viewer_base_url",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": { "baseUrl": { "type": "string" } },
+				"required": ["baseUrl"],
+				"additionalProperties": false
+			},
+			"set_is_app_ready": {
+				"$id": "api/microservice/app/set_is_app_ready",
+				"route": "/set_is_app_ready",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": { "isReady": { "type": "boolean" } },
+				"required": ["isReady"],
+				"additionalProperties": false
+			},
+			"set_back_base_url": {
+				"$id": "api/microservice/app/set_back_base_url",
+				"route": "/set_back_base_url",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": { "baseUrl": { "type": "string" } },
+				"required": ["baseUrl"],
+				"additionalProperties": false
+			},
+			"set_app_base_url": {
+				"$id": "api/microservice/app/set_app_base_url",
+				"route": "/set_app_base_url",
+				"methods": ["POST"],
+				"type": "object",
+				"properties": { "baseUrl": { "type": "string" } },
+				"required": ["baseUrl"],
+				"additionalProperties": false
+			},
+			"get_is_app_ready": {
+				"$id": "api/microservice/app/get_is_app_ready",
+				"route": "/get_is_app_ready",
+				"methods": ["GET"],
+				"type": "object",
+				"properties": {},
+				"required": [],
+				"additionalProperties": false
+			}
+		},
+		"extensions": { "download": {
+			"$id": "api/microservice/extensions/download",
+			"route": "/download",
+			"methods": ["POST"],
+			"type": "object",
+			"properties": {
+				"extension": { "type": "string" },
+				"platform": { "type": "string" }
+			},
+			"required": ["extension", "platform"],
+			"additionalProperties": false
+		} }
+	},
+	"serverless": { "run_cloud": {
+		"$id": "api/serverless/run_cloud",
+		"route": "/run_cloud",
+		"methods": ["POST"],
+		"type": "object",
+		"properties": { "email": { "type": "string" } },
+		"required": ["email"],
+		"additionalProperties": false
+	} }
+};
+//#endregion
+export { api };

package/.build/server/utils/app_config.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { unlink } from "node:fs/promises";
+import Conf from "conf";
+import StreamZip from "node-stream-zip";
+import sanitize from "sanitize-filename";
+//#region server/utils/app_config.ts
+function projectConf(projectName) {
+	const projectConfig = new Conf({ projectName });
+	console.log(projectConf.name, { projectConfig });
+	return projectConfig;
+}
+function confFolderPath(projectName) {
+	const projectConfig = projectConf(projectName);
+	return path.dirname(projectConfig.path);
+}
+function targetExtensionFilePath(projectName, filename) {
+	const safeFilename = sanitize(filename);
+	return path.join(confFolderPath(projectName), safeFilename);
+}
+function extensionsConf(projectName) {
+	const projectConfig = projectConf(projectName);
+	if (!projectConfig.has("extensions")) projectConfig.set("extensions", {});
+	return projectConfig.get("extensions");
+}
+function addExtensionToConf(projectName, { extensionId, extensionPath }) {
+	projectConf(projectName).set(`extensions.${extensionId}.path`, extensionPath);
+}
+function extensionPathFromConf(projectName, extensionId) {
+	return projectConf(projectName).get(`extensions.${extensionId}.path`);
+}
+async function removeExtensionFromConf(projectName, extensionId) {
+	const projectConfig = projectConf(projectName);
+	const extensionArchivePath = extensionPathFromConf(projectName, extensionId);
+	await unlink(extensionArchivePath);
+	console.log(`${extensionArchivePath} was deleted`);
+	projectConfig.delete(`extensions.${extensionId}`);
+	console.log(`${extensionId} was deleted from ${projectName} config`);
+}
+function isExtensionMetadata(value) {
+	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";
+}
+async function registerExtensionFile(projectName, file) {
+	const StreamZipAsync = StreamZip.async;
+	const metadataJson = await new StreamZipAsync({
+		file,
+		storeEntries: true
+	}).entryData("metadata.json");
+	const parsedMetadata = JSON.parse(metadataJson.toString("utf8"));
+	if (!isExtensionMetadata(parsedMetadata)) throw new TypeError("metadata.json does not match the expected ExtensionMetadata shape");
+	const { id } = parsedMetadata;
+	addExtensionToConf(projectName, {
+		extensionId: id,
+		extensionPath: file
+	});
+}
+//#endregion
+export { addExtensionToConf, confFolderPath, extensionPathFromConf, extensionsConf, projectConf, registerExtensionFile, removeExtensionFromConf, targetExtensionFilePath };

package/.build/server/utils/cleanup.js

@@ -0,0 +1,135 @@
+import path from "node:path";
+import fs from "node:fs";
+import { setTimeout } from "node:timers/promises";
+import { WebSocket } from "ws";
+import pTimeout from "p-timeout";
+import { rimraf } from "rimraf";
+//#region server/utils/cleanup.ts
+const MAX_DELETE_FOLDER_RETRIES = 5;
+async function deleteFolderRecursive(folderPath) {
+	if (!fs.existsSync(folderPath)) {
+		console.log(`Folder ${folderPath} does not exist.`);
+		return;
+	}
+	for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) try {
+		console.log(`Deleting folder: ${folderPath}`);
+		await rimraf(folderPath);
+		console.log(`Deleted folder: ${folderPath}`);
+		return;
+	} catch (error) {
+		console.error(`Error deleting folder ${folderPath}:`, error);
+		const DELAY = 1e3 * (i + 1);
+		await setTimeout(DELAY);
+		console.log("Retrying delete folder");
+	}
+	throw new Error(`Failed to delete folder ${folderPath} after ${MAX_DELETE_FOLDER_RETRIES} retries`);
+}
+function isErrorWithMessage(error) {
+	return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+async function killHttpMicroservice(microservice) {
+	console.log("killHttpMicroservice", { ...microservice });
+	const failMessage = `Failed to kill ${microservice.name}`;
+	async function do_kill() {
+		if (microservice.url === void 0) return;
+		try {
+			await fetch(microservice.url, { method: microservice.method });
+		} catch (error) {
+			const message = isErrorWithMessage(error) ? error.message : String(error);
+			console.log(`Expected error during kill of ${microservice.name}:`, message);
+		}
+	}
+	await pTimeout(do_kill(), {
+		milliseconds: 5e3,
+		message: failMessage
+	});
+}
+async function killWebsocketMicroservice(microservice) {
+	console.log("killWebsocketMicroservice", { ...microservice });
+	const failMessage = `Failed to kill ${microservice.name}`;
+	const successMessage = `Disconnected from ${microservice.name} WebSocket server`;
+	async function do_kill() {
+		if (microservice.url === void 0) return;
+		const socketUrl = microservice.url;
+		await new Promise((resolve) => {
+			const socket = new WebSocket(socketUrl);
+			socket.on("open", () => {
+				console.log("Connected to WebSocket server");
+				socket.send(JSON.stringify({
+					id: "system:hello",
+					method: "wslink.hello",
+					args: [{ secret: "wslink-secret" }]
+				}));
+			});
+			socket.on("message", (data) => {
+				const message = data.toString();
+				console.log("Received from server:", message);
+				if (message.includes("hello")) {
+					socket.send(JSON.stringify({
+						id: "application.exit",
+						method: "application.exit"
+					}));
+					console.log(successMessage);
+					socket.close();
+					resolve();
+				}
+			});
+			socket.on("close", () => {
+				console.log(successMessage);
+				resolve();
+			});
+			socket.on("error", (error) => {
+				console.error("WebSocket error:", error);
+				socket.close();
+				resolve();
+			});
+		});
+	}
+	await pTimeout(do_kill(), {
+		milliseconds: 5e3,
+		message: failMessage
+	});
+}
+async function killMicroservice(microservice) {
+	if (microservice.type === "back") await killHttpMicroservice(microservice);
+	else if (microservice.type === "viewer") await killWebsocketMicroservice(microservice);
+	else {
+		const exhaustiveCheck = microservice.type;
+		throw new Error(`Unknown microservice type: ${String(exhaustiveCheck)}`);
+	}
+}
+async function killMicroservices(microservices) {
+	console.log("killMicroservices", { microservices });
+	const results = await Promise.allSettled(microservices.map(async (microservice) => {
+		await killMicroservice(microservice);
+	}));
+	return microservices.filter((_, index) => results[index]?.status !== "fulfilled");
+}
+function microservicesMetadatasPath(projectFolderPath) {
+	return path.join(projectFolderPath, "microservices.json");
+}
+function isMicroservicesMetadatas(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.microservices);
+}
+function projectMicroservices(projectFolderPath) {
+	console.log("projectMicroservices", { projectFolderPath });
+	const filePath = microservicesMetadatasPath(projectFolderPath);
+	if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, JSON.stringify({ microservices: [] }, void 0, 2), "utf8");
+	const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+	if (!isMicroservicesMetadatas(parsed)) throw new Error(`Invalid microservices metadata file: ${filePath}`);
+	return parsed.microservices;
+}
+async function cleanupBackend(projectFolderPath) {
+	if (!fs.existsSync(projectFolderPath)) {
+		console.log(`Folder ${projectFolderPath} does not exist. Skipping cleanup.`);
+		return;
+	}
+	await killMicroservices(projectMicroservices(projectFolderPath));
+	await deleteFolderRecursive(projectFolderPath);
+}
+function getMicroserviceByName(microservices, name) {
+	const found = microservices.find((microservice) => microservice.name === name);
+	return found === void 0 ? void 0 : { ...found };
+}
+//#endregion
+export { cleanupBackend, deleteFolderRecursive, getMicroserviceByName, killMicroservice, microservicesMetadatasPath, projectMicroservices };

package/.build/server/utils/cloud.js

@@ -0,0 +1,156 @@
+import path from "node:path";
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
+import { google } from "googleapis";
+//#region server/utils/cloud.ts
+const LOCATIONS_DIR = "/etc/nginx/locations";
+async function artifactImage(parent, authClient) {
+	const projectName = process.env.PROJECT;
+	const registry = google.artifactregistry({
+		version: "v1",
+		auth: authClient
+	});
+	const branch = process.env.NETLIFY_BRANCH;
+	const [, projectId] = parent.split("/");
+	const name = `${`${parent}/repositories/github/packages/`}${projectName}/tags/${branch}`;
+	console.log({ name });
+	const response = await registry.projects.locations.repositories.packages.tags.get({ name });
+	console.log({ response });
+	const digest = (response.data.version ?? "").split("/").pop();
+	const image = `${`europe-west9-docker.pkg.dev/${projectId}/github`}/${projectName}@${digest}`;
+	console.log("Found image for", projectName, image);
+	return image;
+}
+function sanitizeLabelValue(label) {
+	console.log("label", label);
+	return label.toLowerCase().replaceAll(/[^a-z0-9_-]/gu, "_").slice(0, 63);
+}
+function requestConfig(parent, image, email, projectName) {
+	const resources = {
+		limits: {
+			cpu: "2000m",
+			memory: "3Gi"
+		},
+		cpuIdle: false,
+		startupCpuBoost: true
+	};
+	const labels = {
+		user: sanitizeLabelValue(email),
+		project: sanitizeLabelValue(projectName)
+	};
+	return {
+		parent,
+		service: {
+			ingress: "INGRESS_TRAFFIC_ALL",
+			invokerIamDisabled: true,
+			labels,
+			scaling: {
+				scalingMode: "MANUAL",
+				manualInstanceCount: 1
+			},
+			template: {
+				labels,
+				timeout: { seconds: 3600 },
+				containers: [{
+					image,
+					ports: [{ containerPort: 80 }],
+					resources,
+					env: [{
+						name: "PARENT",
+						value: parent
+					}],
+					startupProbe: {
+						httpGet: {
+							port: 80,
+							path: "/viewer/healthcheck"
+						},
+						periodSeconds: 1,
+						failureThreshold: 30
+					}
+				}]
+			}
+		}
+	};
+}
+function addSupervisorProgram(name, command, executableArgs) {
+	const conf = `
+[program:${name}]
+command=${command} ${executableArgs.join(" ")}
+autostart=true
+autorestart=true
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+`;
+	const confPath = path.join("/etc/supervisor/conf.d", `${name}.conf`);
+	fs.writeFileSync(confPath, conf);
+	execFileSync("supervisorctl", ["reread"]);
+	execFileSync("supervisorctl", ["update"]);
+	const stdout = execFileSync("supervisorctl", ["start", name]);
+	console.log("addSupervisorProgram", stdout);
+}
+function buildLocationBlock(routePath, port) {
+	if (!routePath.startsWith("/") || !routePath.endsWith("/")) throw new Error(`routePath must start and end with '/', got: ${routePath}`);
+	const methods = "GET, POST, PUT, DELETE, PATCH, OPTIONS";
+	return `# ====================== ${routePath} location ======================
+location ~ "^${routePath}" {
+  if ($request_method = 'OPTIONS') {
+    add_header 'Access-Control-Allow-Origin'      $allow_origin always;
+    add_header 'Access-Control-Allow-Credentials' 'true' always;
+    add_header 'Access-Control-Allow-Methods'     '${methods}' always;
+    add_header 'Access-Control-Allow-Headers'     'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,X-CSRF-Token' always;
+    add_header 'Access-Control-Max-Age'           1728000 always;
+    add_header 'Content-Type'                     'text/plain; charset=utf-8';
+    add_header 'Content-Length'                   0;
+    return 204;
+  }
+
+  limit_except ${methods.split(",").map((method) => method.trim()).filter((method) => method !== "OPTIONS").join(" ")} { deny all; }
+
+  add_header 'Access-Control-Allow-Origin'      $allow_origin always;
+  add_header 'Access-Control-Allow-Credentials' 'true' always;
+  add_header 'Access-Control-Allow-Methods'     '${methods}' always;
+  add_header 'Access-Control-Allow-Headers'     'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,X-CSRF-Token' always;
+  add_header 'Access-Control-Expose-Headers'    'Content-Length,Content-Range' always;
+  add_header 'Vary'                             'Origin' always;
+
+  rewrite "^${routePath}(.*)" /$1 break;
+  proxy_pass http://localhost:${port};
+  proxy_http_version 1.1;
+  proxy_set_header Host $host;
+  proxy_set_header X-Real-IP $remote_addr;
+  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+  proxy_set_header X-Forwarded-Proto $scheme;
+}
+`;
+}
+function nginxConfigFile(name) {
+	return path.join(LOCATIONS_DIR, `${name}.conf`);
+}
+function nginxReload() {
+	execFileSync("nginx", ["-t"]);
+	execFileSync("nginx", ["-s", "reload"]);
+}
+function addNginxLocation(name, port) {
+	fs.mkdirSync(LOCATIONS_DIR, { recursive: true });
+	const filePath = nginxConfigFile(name);
+	if (fs.existsSync(filePath)) throw new Error(`Location '${name}' already exists at ${filePath}`);
+	fs.writeFileSync(filePath, buildLocationBlock(`/${name}/`, port));
+	try {
+		nginxReload();
+	} catch (error) {
+		fs.unlinkSync(filePath);
+		throw error;
+	}
+	return filePath;
+}
+function removeNginxLocation(name) {
+	const filePath = nginxConfigFile(name);
+	if (!fs.existsSync(filePath)) return false;
+	fs.unlinkSync(filePath);
+	nginxReload();
+	return true;
+}
+//#endregion
+export { addNginxLocation, addSupervisorProgram, artifactImage, removeNginxLocation, requestConfig };

package/.build/server/utils/microservices.js

@@ -0,0 +1,153 @@
+import { microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
+import { addNginxLocation, addSupervisorProgram } from "./cloud.js";
+import { getAvailablePort, waitForReady } from "./scripts.js";
+import { executablePath } from "./path.js";
+import path from "node:path";
+import fs from "node:fs";
+import child_process from "node:child_process";
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
+//#region server/utils/microservices.ts
+const MILLISECONDS_PER_SECOND = 1e3;
+const DEFAULT_TIMEOUT_SECONDS = 45;
+const MAX_PORT_RETRIES = 1;
+const DEFAULT_RUN_ARGS = { projectFolderPath: "" };
+async function runScript(execPath, execName, args, expectedResponse, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS) {
+	const command = executablePath(execPath, execName);
+	console.log("runScript", command, args);
+	const child = child_process.spawn(command, args, { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	child.name = command.replace(/^.*[\\/]/u, "");
+	child.on("spawn", () => {
+		console.log(`[${child.name}] spawned, pid=${child.pid}`);
+	});
+	const controller = new AbortController();
+	const timer = setTimeout(() => {
+		controller.abort();
+	}, timeoutSeconds * MILLISECONDS_PER_SECOND);
+	if (typeof timer.unref === "function") timer.unref();
+	try {
+		const result = await waitForReady(child, expectedResponse, controller.signal);
+		clearTimeout(timer);
+		return result;
+	} catch (error) {
+		clearTimeout(timer);
+		child.kill();
+		throw error;
+	}
+}
+function isPortInUseError(error) {
+	return /EADDRINUSE|address already in use|port already in use/iu.test(String(error));
+}
+function backArgs(args, port) {
+	const { projectFolderPath } = args;
+	if (!projectFolderPath) throw new Error("projectFolderPath is required");
+	const uploadFolderPath = args.uploadFolderPath !== void 0 && args.uploadFolderPath !== "" ? args.uploadFolderPath : path.join(projectFolderPath, "uploads");
+	const executableArgs = [
+		"--port",
+		String(port),
+		"--project_folder_path",
+		projectFolderPath,
+		"--upload_folder_path",
+		uploadFolderPath,
+		"--allowed_origins",
+		"http://localhost:*",
+		"--timeout",
+		"0"
+	];
+	if (process.env.NODE_ENV === void 0 || process.env.NODE_ENV === "development") executableArgs.push("--debug");
+	return executableArgs;
+}
+async function runBack(execName, execPath, args = DEFAULT_RUN_ARGS, attempts = 0) {
+	let port = void 0;
+	try {
+		port = await getAvailablePort();
+		const executableArgs = backArgs(args, port);
+		console.log("runBack", execPath, execName, executableArgs);
+		await runScript(execPath, execName, executableArgs, "Serving Flask app");
+		return port;
+	} catch (error) {
+		if (!isPortInUseError(error)) {
+			console.log("runBack error", error);
+			throw error;
+		}
+		if (attempts <= MAX_PORT_RETRIES) {
+			console.log("Retrying runBack on conflicting port", port);
+			return await runBack(execName, execPath, args, attempts + 1);
+		}
+	}
+	throw new Error(`runBack failed to run ${execName}`);
+}
+async function runViewer(execName, execPath, args = DEFAULT_RUN_ARGS, attempts = 0) {
+	const { projectFolderPath } = args;
+	if (!projectFolderPath) throw new Error("projectFolderPath is required");
+	let port = void 0;
+	try {
+		port = await getAvailablePort();
+		const viewerArgs = [
+			"--port",
+			String(port),
+			"--project_folder_path",
+			projectFolderPath,
+			"--timeout",
+			"0"
+		];
+		console.log("runViewer", execPath, execName, viewerArgs);
+		await runScript(execPath, execName, viewerArgs, "Starting factory");
+		return port;
+	} catch (error) {
+		if (!isPortInUseError(error)) {
+			console.log("runViewer error", error);
+			throw error;
+		}
+		if (attempts <= MAX_PORT_RETRIES) {
+			console.log("Retrying runViewer on conflicting port", port);
+			return await runViewer(execName, execPath, args, attempts + 1);
+		}
+	}
+	throw new Error(`runViewer failed to run ${execName}`);
+}
+async function runExtension(extensionId, execName, execPath, args = DEFAULT_RUN_ARGS, attempts = 0) {
+	let port = void 0;
+	try {
+		port = await getAvailablePort();
+		const executableArgs = backArgs(args, port);
+		const command = executablePath(execPath, execName);
+		console.log("runExtension", execPath, execName, executableArgs);
+		addSupervisorProgram(extensionId, command, executableArgs);
+		addNginxLocation(extensionId, port);
+		return port;
+	} catch (error) {
+		if (!isPortInUseError(error)) {
+			console.log("runExtension error", error);
+			throw error;
+		}
+		if (attempts <= MAX_PORT_RETRIES) {
+			console.log("Retrying runExtension on conflicting port", port);
+			return await runExtension(extensionId, execName, execPath, args, attempts + 1);
+		}
+	}
+	throw new Error(`runExtension failed to run ${extensionId}`);
+}
+function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
+	const microservices = projectMicroservices(projectFolderPath);
+	let enriched = { ...serviceObj };
+	if (serviceObj.type === "back") {
+		const schema = back_schemas.opengeodeweb_back.kill;
+		const [method] = schema.methods;
+		enriched = {
+			...enriched,
+			url: `http://localhost:${serviceObj.port}/${schema.$id}`,
+			method
+		};
+	} else if (serviceObj.type === "viewer") enriched = {
+		...enriched,
+		url: `ws://localhost:${serviceObj.port}/ws`
+	};
+	microservices.push(enriched);
+	fs.writeFileSync(microservicesMetadatasPath(projectFolderPath), JSON.stringify({ microservices }, void 0, 2));
+}
+//#endregion
+export { addMicroserviceMetadatas, runBack, runExtension, runViewer };