@geode/opengeodeweb-front 10.36.0-rc.3 → 10.36.0-rc.5

package/.build/opengeodeweb_front_schemas.js

@@ -181,7 +181,8 @@ var api = {
 									"name": { "type": "string" },
 									"version": { "type": "string" },
 									"frontendContent": { "type": "string" },
-									"port": { "type": "integer" }
+									"port": { "type": "integer" },
+									"serverPort": { "type": "integer" }
 								},
 								"required": [
 									"id",

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

@@ -9,9 +9,10 @@ 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 DEFAULT_TIMEOUT_SECONDS = 120;
 const MAX_PORT_RETRIES = 1;
 const DEFAULT_RUN_ARGS = { projectFolderPath: "" };
+const LISTENING_LOG_PATTERN = /^Listening on https?:\/\/.+:\d+\/?\s*$/mu;
 async function runScript(execPath, execName, args, expectedResponse, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS) {
 	const command = executablePath(execPath, execName);
 	consola.debug("runScript", command, args);
@@ -132,6 +133,47 @@ async function runExtension(extensionId, execName, execPath, args = DEFAULT_RUN_
 	}
 	throw new Error(`runExtension failed to run ${extensionId}`);
 }
+async function waitUntilListening(child) {
+	child.stderr.on("data", (data) => {
+		consola.info(`[${child.spawnfile}] STDERR:`, data.toString().trim());
+	});
+	child.on("close", (code) => {
+		consola.info(`[${child.spawnfile}] exited with code ${code}`);
+	});
+	for await (const chunk of child.stdout) {
+		const output = String(chunk);
+		consola.info(`[${child.spawnfile}] STDOUT:`, output.trim());
+		if (LISTENING_LOG_PATTERN.test(output)) {
+			child.stdout.on("data", (data) => {
+				consola.info(`[${child.spawnfile}] STDOUT:`, data.toString().trim());
+			});
+			return;
+		}
+	}
+	throw new Error(`${child.spawnfile} exited before becoming ready`);
+}
+async function runExtensionServer(entryPath, attempts = 0) {
+	let port = void 0;
+	try {
+		port = await getAvailablePort();
+		consola.info("runExtensionServer", entryPath, port);
+		await waitUntilListening(child_process.spawn("node", [entryPath], { env: {
+			...process.env,
+			PORT: String(port)
+		} }));
+		return port;
+	} catch (error) {
+		if (!isPortInUseError(error)) {
+			consola.error("runExtensionServer error", error);
+			throw error;
+		}
+		if (attempts <= MAX_PORT_RETRIES) {
+			consola.warn("Retrying runExtensionServer on conflicting port", port);
+			return await runExtensionServer(entryPath, attempts + 1);
+		}
+	}
+	throw new Error(`runExtensionServer failed to run ${entryPath}`);
+}
 function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
 	const microservices = projectMicroservices(projectFolderPath);
 	let enriched = { ...serviceObj };
@@ -151,4 +193,4 @@ function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
 	fs.writeFileSync(microservicesMetadatasPath(projectFolderPath), JSON.stringify({ microservices }, void 0, 2));
 }
 //#endregion
-export { addMicroserviceMetadatas, runBack, runExtension, runViewer };
+export { addMicroserviceMetadatas, runBack, runExtension, runExtensionServer, runViewer };

package/.build/server/utils/path.js

@@ -105,5 +105,8 @@ function extensionBackendPath(unzippedExtensionPath, backendExecutableName) {
 	consola.debug("runExtensions", { backendExecutablePath });
 	return backendExecutablePath;
 }
+function extensionServerEntryPath(unzippedExtensionPath, entry) {
+	return path.join(unzippedExtensionPath, entry);
+}
 //#endregion
-export { createPath, executableName, executablePath, extensionBackendPath, extensionFolderPath, extensionFrontendPath, generateProjectFolderPath };
+export { createPath, executableName, executablePath, extensionBackendPath, extensionFolderPath, extensionFrontendPath, extensionServerEntryPath, generateProjectFolderPath };

package/.build/server/utils/server_config.js

@@ -3,6 +3,7 @@ import { createServerWsRpcClient } from "./ws_client.js";
 const stringStorage = /* @__PURE__ */ new Map();
 const booleanStorage = /* @__PURE__ */ new Map();
 const clientStorage = /* @__PURE__ */ new Map();
+const extensionServerPorts = /* @__PURE__ */ new Map();
 function getAppBaseUrl() {
 	const value = stringStorage.get("APP_BASE_URL");
 	if (value === void 0) throw new Error("APP_BASE_URL is not set");
@@ -47,5 +48,14 @@ async function getViewerWebSocketClient() {
 	if (viewerClient !== void 0 && viewerClient.isOpen()) return viewerClient;
 	return await setViewerWebSocketClient(getViewerBaseUrl());
 }
+function setExtensionServerPort(extensionId, port) {
+	extensionServerPorts.set(extensionId, port);
+}
+function getExtensionServerPort(extensionId) {
+	return extensionServerPorts.get(extensionId);
+}
+function getExtensionServerPorts() {
+	return extensionServerPorts;
+}
 //#endregion
-export { getAppBaseUrl, getBackBaseUrl, getIsAppReady, getViewerBaseUrl, getViewerWebSocketClient, setAppBaseUrl, setBackBaseUrl, setIsAppReady, setViewerBaseUrl, setViewerWebSocketClient };
+export { getAppBaseUrl, getBackBaseUrl, getExtensionServerPort, getExtensionServerPorts, getIsAppReady, getViewerBaseUrl, getViewerWebSocketClient, setAppBaseUrl, setBackBaseUrl, setExtensionServerPort, setIsAppReady, setViewerBaseUrl, setViewerWebSocketClient };

package/app/components/Viewer/ObjectTree/Base/ItemLabel.vue

@@ -29,6 +29,7 @@ const { width: containerWidth } = useElementSize(labelContainer);
 // The item prop can be either a DisplayItem wrapper (with a `.raw` domain object) or the domain object itself when this component is used outside CommonTreeView's slot machinery; the domain object always carries an id/title at runtime.
 interface LabeledItem {
   id: string;
+  geode_id?: string;
   title?: string;
   is_active?: boolean;
   category?: string;
@@ -96,9 +97,9 @@ async function copyToClipboard(text: string, label: string): Promise<void> {
       </template>
 
       <div class="d-flex flex-column ga-1">
-        <span class="text-caption d-flex align-center">
+        <span v-if="actualItem.geode_id" class="text-caption d-flex align-center">
           <strong class="text-white mr-1">ID:</strong>
-          <span data-testid="tooltipIdValue">{{ actualItem.id }}</span>
+          <span data-testid="tooltipIdValue">{{ actualItem.geode_id }}</span>
           <v-btn
             data-testid="copyIdBtn"
             icon
@@ -106,7 +107,7 @@ async function copyToClipboard(text: string, label: string): Promise<void> {
             density="compact"
             class="ml-1 text-white"
             style="width: 18px; height: 18px; min-width: 18px; min-height: 18px"
-            @click.stop="copyToClipboard(actualItem.id, 'ID')"
+            @click.stop="copyToClipboard(actualItem.geode_id, 'ID')"
           >
             <v-icon size="12">mdi-content-copy</v-icon>
           </v-btn>

package/app/composables/tree_filter.ts

@@ -7,6 +7,8 @@ type ReadonlyMaybeRefOrGetter<Value> = Value | Ref<Value> | (() => Value);
 interface FilterableItem {
   readonly id: unknown;
   readonly title?: string;
+  // Present on geode objects (data and model components), absent on group nodes.
+  readonly geode_id?: string;
   readonly children?: readonly FilterableItem[];
 }
 
@@ -46,15 +48,15 @@ function customFilter(
     return false;
   }
   const query = searchQuery.toLowerCase();
-  const { title = "", id = value } = item.raw;
-  return [title, id].some((field) => String(field).toLowerCase().includes(query));
+  const { title = "", id = value, geode_id: geodeId } = item.raw;
+  return [title, id, geodeId].some((field) => String(field).toLowerCase().includes(query));
 }
 
 // Extracted so we never call String() directly on a value typed as `unknown`/`any`.
 // The `id` field can be anything at runtime, so only stringify primitives that have a sane toString.
 // Anything else falls back to "" instead of risking "[object Object]".
 function toSortKey(item: FilterableItem, field: "title" | "id"): string {
-  const raw = item[field] ?? item.id ?? "";
+  const raw = (field === "id" ? item.geode_id : item.title) ?? item.id ?? "";
   if (typeof raw === "string" || typeof raw === "number" || typeof raw === "boolean") {
     return String(raw);
   }
@@ -136,7 +138,7 @@ function useTreeFilter(
       const children = (category.children ?? []).filter((child) =>
         customFilter(child.id, search.value, { raw: child }),
       );
-      if (children.length > 0 || customFilter(category.id, search.value, { raw: category })) {
+      if (children.length > 0) {
         result.push({ ...category, children });
       }
     }

package/app/stores/app_helpers/extension.ts

@@ -59,6 +59,7 @@ export function useAppExtensions(): {
   async function loadExtension(
     path: string,
     extensionPort: string,
+    serverPort?: string,
     backendPath?: string,
   ): Promise<ExtensionModule> {
     try {
@@ -77,7 +78,10 @@ export function useAppExtensions(): {
       // oxlint-disable-next-line no-inline-comments, no-unsafe-assignment
       const extensionModule: ExtensionModule = await import(/* @vite-ignore */ finalURL);
       const store = extensionModule.metadata.store();
-      store.$patch?.({ default_local_port: extensionPort });
+      store.$patch?.({
+        default_local_port: extensionPort,
+        ...(serverPort === undefined ? {} : { nitro_port: serverPort }),
+      });
 
       if (finalURL !== path && finalURL.startsWith("blob:")) {
         URL.revokeObjectURL(finalURL);

package/app/stores/data.ts

@@ -13,6 +13,7 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 
 interface DataItem {
   id: string;
+  geode_id: string;
   name: string;
   viewer_type: string;
   geode_object_type: string;
@@ -35,6 +36,7 @@ interface ModelComponentInput {
 
 interface NewDataItem {
   id: string;
+  geode_id: string;
   name?: string;
   viewer_type: string;
   geode_object_type: string;
@@ -199,6 +201,7 @@ export const useDataStore = defineStore("data", () => {
   async function addItem(new_item: NewDataItem): Promise<string> {
     const itemData: DataItem = {
       id: new_item.id,
+      geode_id: new_item.geode_id,
       name: new_item.name ?? new_item.id,
       viewer_type: new_item.viewer_type,
       geode_object_type: new_item.geode_object_type,

package/app/stores/data_helpers/collections.ts

@@ -59,6 +59,7 @@ export function useDataCollections(): {
       .filter((component: ModelComponentRecord) => !MESH_COMPONENT_TYPES.includes(component.type))
       .map((component: ModelComponentRecord) => ({
         id: component.geode_id,
+        geode_id: component.geode_id,
         title: component.name,
         category: component.type,
         viewer_id: Number(component.viewer_id),

package/app/stores/data_helpers/mesh.ts

@@ -14,6 +14,7 @@ interface ModelComponentRecord {
 
 interface FormattedComponent {
   readonly id: string;
+  readonly geode_id: string;
   readonly title: string;
   readonly category: string;
   readonly viewer_id: number;
@@ -29,6 +30,7 @@ interface FormattedComponentGroup {
 function toFormattedComponent(meshComponent: ModelComponentRecord): FormattedComponent {
   return {
     id: meshComponent.geode_id,
+    geode_id: meshComponent.geode_id,
     title: meshComponent.name,
     category: meshComponent.type,
     viewer_id: Math.trunc(Number(meshComponent.viewer_id)),

package/app/stores/treeview.ts

@@ -25,6 +25,7 @@ interface OpenedView {
 interface TreeviewChild {
   title: string;
   id: string;
+  geode_id: string;
   viewer_type: string;
   geode_object_type: string;
 }
@@ -170,10 +171,17 @@ export const useTreeviewStore = defineStore("treeview", () => {
     }
   }
 
-  function addItem(geodeObjectType: string, name: string, id: string, viewer_type: string): void {
+  function addItem(
+    geodeObjectType: string,
+    name: string,
+    id: string,
+    geode_id: string,
+    viewer_type: string,
+  ): void {
     const child: TreeviewChild = {
       title: name,
       id,
+      geode_id,
       viewer_type,
       geode_object_type: geodeObjectType,
     };

package/app/utils/extension.ts

@@ -15,6 +15,7 @@ interface ExtensionDescriptor {
   version: string;
   frontendContent: string;
   port: number;
+  serverPort?: number;
 }
 
 interface DownloadExtensionParams {
@@ -87,12 +88,16 @@ async function registerRunningExtensions(): Promise<RegisteredExtension[]> {
   const { extensionsArray } = await runExtensions();
   return Promise.all(
     extensionsArray.map(async (extension: ExtensionDescriptor) => {
-      const { id, name, version, frontendContent, port } = extension;
+      const { id, name, version, frontendContent, port, serverPort } = extension;
       const blob = new Blob([frontendContent], {
         type: "application/javascript",
       });
       const blobUrl = URL.createObjectURL(blob);
-      const extensionModule = await appStore.loadExtension(blobUrl, String(port));
+      const extensionModule = await appStore.loadExtension(
+        blobUrl,
+        String(port),
+        serverPort === undefined ? undefined : String(serverPort),
+      );
       consola.info("[ExtensionManager] Extension loaded:", id);
       const storeFactory = extensionModule.metadata.store;
       const store = storeFactory();

package/app/utils/import_workflow.ts

@@ -38,7 +38,13 @@ async function importItem(item: NewDataItem): Promise<string> {
     item.viewer_type === "model" ? dataStore.addComponents(item) : Promise.resolve();
   const addDataRelationsTask =
     item.viewer_type === "model" ? dataStore.addComponentRelations(item) : Promise.resolve();
-  treeviewStore.addItem(item.geode_object_type, item.name ?? item.id, item.id, item.viewer_type);
+  treeviewStore.addItem(
+    item.geode_object_type,
+    item.name ?? item.id,
+    item.id,
+    item.geode_id,
+    item.viewer_type,
+  );
   const addDataStyleTask = dataStyleStore.addDataStyle(item.id, item.geode_object_type);
   const addViewerTask = addDataTask.then(async () => {
     if (!(await dataStore.isItemViewable(item))) {
@@ -80,6 +86,9 @@ async function importFile(filename: string, geode_object_type: string): Promise<
 }
 
 async function importWorkflow(files: readonly FileToImport[]): Promise<string[]> {
+  const hybridViewerStore = useHybridViewerStore();
+  // Files are imported concurrently and the viewer only frames the first actor to arrive, so the camera is reset once everything is loaded
+  const wasSceneEmpty = Object.keys(hybridViewerStore.hybridDb).length === 0;
   const chunk_size = 5;
   const chunks: FileToImport[][] = [];
   for (let i = 0; i < files.length; i += chunk_size) {
@@ -102,7 +111,10 @@ async function importWorkflow(files: readonly FileToImport[]): Promise<string[]>
     await processChunk(chunkIndex + 1);
   }
   await processChunk(0);
-  const hybridViewerStore = useHybridViewerStore();
+  const isSceneFilled = Object.keys(hybridViewerStore.hybridDb).length > 0;
+  if (wasSceneEmpty && isSceneFilled) {
+    hybridViewerStore.resetCamera();
+  }
   await hybridViewerStore.remoteRender();
   return results;
 }

package/internal/database/tables/data.ts

@@ -2,5 +2,6 @@ import type { TableDefinition } from "./table_definition";
 
 export const dataTable: TableDefinition = {
   name: "data",
-  schema: "id, name, viewer_type, geode_object_type, visible, created_at, binary_light_viewable",
+  schema:
+    "id, geode_id, name, viewer_type, geode_object_type, visible, created_at, binary_light_viewable",
 };

package/opengeodeweb_front_schemas.json

@@ -241,6 +241,9 @@
                     },
                     "port": {
                       "type": "integer"
+                    },
+                    "serverPort": {
+                      "type": "integer"
                     }
                   },
                   "required": ["id", "name", "version", "frontendContent", "port"],

package/opengeodeweb_front_typed_schemas.d.ts

@@ -90,6 +90,7 @@ export interface LocalExtensionsRunResponseExtensionsArray {
   id: string;
   name: string;
   port: number;
+  serverPort?: number;
   version: string;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.36.0-rc.3",
+  "version": "10.36.0-rc.5",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {

package/server/api/local/extensions/run.post.ts

@@ -7,54 +7,73 @@ import fs from "node:fs";
 import {
   addMicroserviceMetadatas,
   runBack,
+  runExtensionServer,
 } from "@geode/opengeodeweb-front/server/utils/microservices.ts";
 import {
   extensionBackendPath,
   extensionFolderPath,
+  extensionServerEntryPath,
 } from "@geode/opengeodeweb-front/server/utils/path.ts";
 import {
   readExtensionFrontend,
   readExtensionMetadata,
 } from "@geode/opengeodeweb-front/server/utils/extension.ts";
 import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.ts";
+import { setExtensionServerPort } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
 import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.ts";
 
 import { defineTypedEventHandler } from "@geode/opengeodeweb-front/server/utils/typed_handler.ts";
 import schemas from "@geode/opengeodeweb-front/opengeodeweb_front_typed_schemas.js";
 
+async function runSingleExtension(
+  extensionPath: string,
+  extensionId: string,
+  projectFolderPath: string,
+): Promise<{
+  id: string;
+  name: string;
+  version: string;
+  frontendContent: string;
+  port: number;
+  serverPort: number | undefined;
+}> {
+  const unzippedExtensionPath = await unzipFile(
+    extensionPath,
+    extensionFolderPath(projectFolderPath, extensionId),
+  );
+  const { id, name, version, backendExecutable, server, frontendFile } =
+    await readExtensionMetadata(unzippedExtensionPath);
+  const frontendContent = await readExtensionFrontend(unzippedExtensionPath, frontendFile, id);
+
+  fs.chmodSync(extensionBackendPath(unzippedExtensionPath, backendExecutable), "755");
+  const port = await runBack(backendExecutable, unzippedExtensionPath, {
+    projectFolderPath,
+  });
+  addMicroserviceMetadatas(projectFolderPath, {
+    type: "back",
+    name,
+    port,
+  });
+
+  const serverPort =
+    server === undefined
+      ? undefined
+      : await runExtensionServer(extensionServerEntryPath(unzippedExtensionPath, server.entry));
+  if (serverPort !== undefined) {
+    setExtensionServerPort(id, serverPort);
+  }
+
+  return { id, name, version, frontendContent, port, serverPort };
+}
+
 export default defineTypedEventHandler(
   schemas.api.local.extensions.run,
   async ({ projectFolderPath, projectName }) => {
     const extensionsConfig = extensionsConf(projectName);
     const extensionsArray = await Promise.all(
       Object.entries(extensionsConfig).map(async ([extensionId, { path: extensionPath }]) => {
-        const unzippedExtensionPath = await unzipFile(
-          extensionPath,
-          extensionFolderPath(projectFolderPath, extensionId),
-        );
-        const { id, name, version, backendExecutable, frontendFile } =
-          await readExtensionMetadata(unzippedExtensionPath);
-        const frontendContent = await readExtensionFrontend(
-          unzippedExtensionPath,
-          frontendFile,
-          id,
-        );
-        fs.chmodSync(extensionBackendPath(unzippedExtensionPath, backendExecutable), "755");
-        const port = await runBack(backendExecutable, unzippedExtensionPath, {
-          projectFolderPath,
-        });
-        addMicroserviceMetadatas(projectFolderPath, {
-          type: "back",
-          name,
-          port,
-        });
-        return {
-          id,
-          name,
-          version,
-          frontendContent,
-          port,
-        };
+        const result = await runSingleExtension(extensionPath, extensionId, projectFolderPath);
+        return result;
       }),
     );
 

package/server/api/local/extensions/schemas/run.json

@@ -37,6 +37,9 @@
             },
             "port": {
               "type": "integer"
+            },
+            "serverPort": {
+              "type": "integer"
             }
           },
           "required": ["id", "name", "version", "frontendContent", "port"],

package/server/utils/extension.ts

@@ -10,6 +10,10 @@ import { createError } from "h3";
 // Local imports
 import { extensionFrontendPath } from "@geode/opengeodeweb-front/server/utils/path.ts";
 
+const extensionServerMetadataSchema = z.object({
+  entry: z.string(),
+});
+
 const extensionMetadataSchema = z
   .object({
     id: z.string(),
@@ -17,6 +21,7 @@ const extensionMetadataSchema = z
     version: z.string(),
     frontendFile: z.string(),
     backendExecutable: z.string(),
+    server: extensionServerMetadataSchema.optional(),
   })
   .loose();
 

package/server/utils/microservices.ts

@@ -20,9 +20,10 @@ interface RunArgs {
 }
 
 const MILLISECONDS_PER_SECOND = 1000;
-const DEFAULT_TIMEOUT_SECONDS = 45;
+const DEFAULT_TIMEOUT_SECONDS = 120;
 const MAX_PORT_RETRIES = 1;
 const DEFAULT_RUN_ARGS: RunArgs = { projectFolderPath: "" };
+const LISTENING_LOG_PATTERN = /^Listening on https?:\/\/.+:\d+\/?\s*$/mu;
 
 async function runScript(
   execPath: string,
@@ -183,6 +184,56 @@ async function runExtension(
   }
   throw new Error(`runExtension failed to run ${extensionId}`);
 }
+async function waitUntilListening(
+  child: child_process.ChildProcessWithoutNullStreams,
+): Promise<void> {
+  child.stderr.on("data", (data: Buffer) => {
+    consola.info(`[${child.spawnfile}] STDERR:`, data.toString().trim());
+  });
+  child.on("close", (code) => {
+    consola.info(`[${child.spawnfile}] exited with code ${code}`);
+  });
+  // oxlint-disable-next-line typescript/no-unnecessary-condition
+  for await (const chunk of child.stdout) {
+    const output = String(chunk);
+    consola.info(`[${child.spawnfile}] STDOUT:`, output.trim());
+    if (LISTENING_LOG_PATTERN.test(output)) {
+      child.stdout.on("data", (data: Buffer) => {
+        consola.info(`[${child.spawnfile}] STDOUT:`, data.toString().trim());
+      });
+      return;
+    }
+  }
+  throw new Error(`${child.spawnfile} exited before becoming ready`);
+}
+
+async function runExtensionServer(entryPath: string, attempts = 0): Promise<number> {
+  let port: number | undefined = undefined;
+  try {
+    port = await getAvailablePort();
+    consola.info("runExtensionServer", entryPath, port);
+    const child = child_process.spawn("node", [entryPath], {
+      env: {
+        ...process.env,
+        PORT: String(port),
+      },
+    });
+    await waitUntilListening(child);
+    return port;
+  } catch (error) {
+    if (!isPortInUseError(error)) {
+      consola.error("runExtensionServer error", error);
+      throw error;
+    }
+    if (attempts <= MAX_PORT_RETRIES) {
+      consola.warn("Retrying runExtensionServer on conflicting port", port);
+      const newPort = await runExtensionServer(entryPath, attempts + 1);
+      return newPort;
+    }
+  }
+  throw new Error(`runExtensionServer failed to run ${entryPath}`);
+}
+
 function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microservice): void {
   const microservices = projectMicroservices(projectFolderPath);
   let enriched: Microservice = { ...serviceObj };
@@ -213,4 +264,4 @@ function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microse
   );
 }
 
-export { addMicroserviceMetadatas, runBack, runExtension, runViewer };
+export { addMicroserviceMetadatas, runBack, runExtension, runExtensionServer, runViewer };

package/server/utils/path.ts

@@ -163,11 +163,15 @@ function extensionBackendPath(
   });
   return backendExecutablePath;
 }
+function extensionServerEntryPath(unzippedExtensionPath: string, entry: string): string {
+  return path.join(unzippedExtensionPath, entry);
+}
 export {
   createPath,
   extensionBackendPath,
   extensionFrontendPath,
   extensionFolderPath,
+  extensionServerEntryPath,
   executablePath,
   executableName,
   generateProjectFolderPath,

package/server/utils/server_config.ts

@@ -3,6 +3,7 @@ import { type ServerWsRpcClient, createServerWsRpcClient } from "./ws_client.js"
 const stringStorage = new Map<string, string>();
 const booleanStorage = new Map<string, boolean>();
 const clientStorage = new Map<string, ServerWsRpcClient>();
+const extensionServerPorts = new Map<string, number>();
 
 function getAppBaseUrl(): string {
   const value = stringStorage.get("APP_BASE_URL");
@@ -60,14 +61,27 @@ async function getViewerWebSocketClient(): Promise<ServerWsRpcClient> {
   const client = await setViewerWebSocketClient(viewerBaseUrl);
   return client;
 }
+function setExtensionServerPort(extensionId: string, port: number): void {
+  extensionServerPorts.set(extensionId, port);
+}
+function getExtensionServerPort(extensionId: string): number | undefined {
+  return extensionServerPorts.get(extensionId);
+}
+function getExtensionServerPorts(): ReadonlyMap<string, number> {
+  return extensionServerPorts;
+}
+
 export {
   getAppBaseUrl,
   getBackBaseUrl,
+  getExtensionServerPort,
+  getExtensionServerPorts,
   getIsAppReady,
   getViewerBaseUrl,
   getViewerWebSocketClient,
   setAppBaseUrl,
   setBackBaseUrl,
+  setExtensionServerPort,
   setIsAppReady,
   setViewerBaseUrl,
   setViewerWebSocketClient,