@sap-ux/backend-proxy-middleware-cf 0.2.10 → 0.3.0

package/dist/approuter/approuter.d.ts

@@ -1,6 +1,6 @@
 import createApprouter from '@sap/approuter';
 import type { ToolsLogger } from '@sap-ux/logger';
-import type { XsappConfig } from '../types';
+import type { XsappConfig } from '../types.js';
 /**
  * Options for starting the approuter.
  */

package/dist/approuter/approuter.js

@@ -1,19 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startApprouter = startApprouter;
-const approuter_1 = __importDefault(require("@sap/approuter"));
+import createApprouter from '@sap/approuter';
 /**
  * Start the approuter and register it globally for cleanup.
  *
  * @param options - Approuter start options.
  * @returns The started approuter instance.
  */
-function startApprouter(options) {
+export function startApprouter(options) {
     const { port, xsappConfig, rootPath, modules, logger } = options;
-    const approuter = (0, approuter_1.default)();
+    const approuter = createApprouter();
     try {
         approuter.start({
             port,

package/dist/approuter/extensions.d.ts

@@ -1,5 +1,5 @@
 import type { ToolsLogger } from '@sap-ux/logger';
-import type { ApprouterExtension, ExtensionModule, LoadedExtensions } from '../types';
+import type { ApprouterExtension, ExtensionModule, LoadedExtensions } from '../types.js';
 /**
  * Load and prepare extension modules for the approuter.
  *

package/dist/approuter/extensions.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadExtensions = loadExtensions;
-exports.getExtensionRoutes = getExtensionRoutes;
-exports.toExtensionModule = toExtensionModule;
+import { createRequire } from 'node:module';
 /**
  * Create a wrapper that injects parameters as 4th argument for approuter extension handlers.
  *
@@ -24,7 +20,7 @@ function createParametersInjector(middleware, params) {
  * @param logger - Logger instance.
  * @returns Loaded extension modules and list of extension routes (paths) they register.
  */
-function loadExtensions(rootPath, extensions, logger) {
+export function loadExtensions(rootPath, extensions, logger) {
     const modules = (extensions ?? [])
         .map((extension) => toExtensionModule(extension, rootPath, logger))
         .filter((e) => e != null);
@@ -37,7 +33,7 @@ function loadExtensions(rootPath, extensions, logger) {
  * @param extensionModule - The extension module to inspect.
  * @returns Array of path strings from insertMiddleware entries that define a path.
  */
-function getExtensionRoutes(extensionModule) {
+export function getExtensionRoutes(extensionModule) {
     const insertMiddleware = extensionModule.insertMiddleware;
     if (!insertMiddleware) {
         return [];
@@ -61,11 +57,11 @@ function getExtensionRoutes(extensionModule) {
  * @param logger - The logger to use.
  * @returns The extension module, or undefined if the module cannot be resolved.
  */
-function toExtensionModule(extension, rootPath, logger) {
+export function toExtensionModule(extension, rootPath, logger) {
     try {
-        const extensionModulePath = require.resolve(extension.module, { paths: [rootPath] });
-        // eslint-disable-next-line @typescript-eslint/no-require-imports -- dynamic user extension path
-        const originalModule = require(extensionModulePath);
+        const esmRequire = createRequire(import.meta.url);
+        const extensionModulePath = esmRequire.resolve(extension.module, { paths: [rootPath] });
+        const originalModule = esmRequire(extensionModulePath);
         const insertMiddleware = originalModule?.insertMiddleware;
         if (!insertMiddleware) {
             return originalModule;

package/dist/config/config.d.ts

@@ -1,4 +1,4 @@
-import type { BackendProxyMiddlewareCfConfig, EffectiveOptions } from '../types';
+import type { BackendProxyMiddlewareCfConfig, EffectiveOptions } from '../types.js';
 export declare const DEFAULT_REWRITE_CONTENT_TYPES: string[];
 /**
  * Merge user configuration with defaults.

package/dist/config/config.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_REWRITE_CONTENT_TYPES = void 0;
-exports.mergeEffectiveOptions = mergeEffectiveOptions;
-const adp_tooling_1 = require("@sap-ux/adp-tooling");
-exports.DEFAULT_REWRITE_CONTENT_TYPES = [
+import { DEFAULT_TUNNEL_APP_NAME } from '@sap-ux/adp-tooling';
+export const DEFAULT_REWRITE_CONTENT_TYPES = [
     'text/html',
     'application/json',
     'application/atom+xml',
@@ -15,7 +11,7 @@ exports.DEFAULT_REWRITE_CONTENT_TYPES = [
  * @param configuration - Configuration from ui5.yaml.
  * @returns Effective options with all defaults applied.
  */
-function mergeEffectiveOptions(configuration) {
+export function mergeEffectiveOptions(configuration) {
     return {
         debug: false,
         port: 5000,
@@ -25,12 +21,12 @@ function mergeEffectiveOptions(configuration) {
         authenticationMethod: 'none',
         allowLocalDir: false,
         rewriteContent: true,
-        rewriteContentTypes: [...exports.DEFAULT_REWRITE_CONTENT_TYPES],
+        rewriteContentTypes: [...DEFAULT_REWRITE_CONTENT_TYPES],
         appendAuthRoute: false,
         disableWelcomeFile: false,
         disableUi5ServerRoutes: false,
         disableSshTunnel: false,
-        tunnelAppName: adp_tooling_1.DEFAULT_TUNNEL_APP_NAME,
+        tunnelAppName: DEFAULT_TUNNEL_APP_NAME,
         skipSshEnable: false,
         extensions: [],
         ...configuration

package/dist/config/constants.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROXY_MARKER_HEADER = exports.UI5_SERVER_DESTINATION = void 0;
 /**
  * Destination name for the local UI5 server (used in xs-app.json routes and env config).
  */
-exports.UI5_SERVER_DESTINATION = 'ui5-server';
+export const UI5_SERVER_DESTINATION = 'ui5-server';
 /**
  * Header set by the proxy on requests forwarded to the approuter.
  * Used to detect approuter loop-back requests and prevent infinite loops.
  */
-exports.PROXY_MARKER_HEADER = 'x-backend-proxy-middleware-cf';
+export const PROXY_MARKER_HEADER = 'x-backend-proxy-middleware-cf';
 //# sourceMappingURL=constants.js.map

package/dist/config/env.d.ts

@@ -1,6 +1,6 @@
 import type { ToolsLogger } from '@sap-ux/logger';
 import type { AppRouterEnvOptions } from '@sap-ux/adp-tooling';
-import type { ConnectivityProxyInfo, EffectiveOptions } from '../types';
+import type { ConnectivityProxyInfo, EffectiveOptions } from '../types.js';
 /**
  * Extract connectivity proxy host and port from VCAP_SERVICES.
  *

package/dist/config/env.js

@@ -1,23 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConnectivityProxyInfo = getConnectivityProxyInfo;
-exports.applyToProcessEnv = applyToProcessEnv;
-exports.loadEnvOptions = loadEnvOptions;
-exports.updateUi5ServerDestinationPort = updateUi5ServerDestinationPort;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const adp_tooling_1 = require("@sap-ux/adp-tooling");
-const constants_1 = require("./constants");
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildVcapServicesFromResources, getSpaceGuidFromUi5Yaml, getYamlContent } from '@sap-ux/adp-tooling';
+import { UI5_SERVER_DESTINATION } from './constants.js';
 /**
  * Extract connectivity proxy host and port from VCAP_SERVICES.
  *
  * @param vcapServices - Parsed VCAP_SERVICES object.
  * @returns Proxy info or undefined if no connectivity service is present.
  */
-function getConnectivityProxyInfo(vcapServices) {
+export function getConnectivityProxyInfo(vcapServices) {
     if (!vcapServices) {
         return undefined;
     }
@@ -42,12 +33,12 @@ function getConnectivityProxyInfo(vcapServices) {
  * @returns Parsed options object.
  */
 function loadEnvOptionsFromFile(rootPath, envOptionsPath) {
-    const resolvedPath = node_path_1.default.resolve(rootPath, envOptionsPath);
-    if (!node_fs_1.default.existsSync(resolvedPath)) {
+    const resolvedPath = path.resolve(rootPath, envOptionsPath);
+    if (!fs.existsSync(resolvedPath)) {
         throw new Error(`Env options file not found at "${resolvedPath}" (envOptionsPath: "${envOptionsPath}").`);
     }
     try {
-        const content = node_fs_1.default.readFileSync(resolvedPath, 'utf8');
+        const content = fs.readFileSync(resolvedPath, 'utf8');
         return JSON.parse(content);
     }
     catch (err) {
@@ -61,7 +52,7 @@ function loadEnvOptionsFromFile(rootPath, envOptionsPath) {
  *
  * @param options - Env options to apply.
  */
-function applyToProcessEnv(options) {
+export function applyToProcessEnv(options) {
     if (options.VCAP_SERVICES) {
         const connectivity = options.VCAP_SERVICES['connectivity'];
         if (Array.isArray(connectivity)) {
@@ -91,7 +82,7 @@ function applyToProcessEnv(options) {
  * @param logger - Logger for CF path.
  * @returns Loaded and merged env options.
  */
-async function loadEnvOptions(rootPath, effectiveOptions, logger) {
+export async function loadEnvOptions(rootPath, effectiveOptions, logger) {
     const { envOptionsPath, destinations: middlewareDestinations } = effectiveOptions;
     if (envOptionsPath) {
         const envOptions = loadEnvOptionsFromFile(rootPath, envOptionsPath);
@@ -100,16 +91,16 @@ async function loadEnvOptions(rootPath, effectiveOptions, logger) {
             : middlewareDestinations;
         return { ...envOptions, destinations };
     }
-    const mtaPath = node_path_1.default.resolve(rootPath, '..', 'mta.yaml');
-    const spaceGuid = await (0, adp_tooling_1.getSpaceGuidFromUi5Yaml)(rootPath, logger);
+    const mtaPath = path.resolve(rootPath, '..', 'mta.yaml');
+    const spaceGuid = await getSpaceGuidFromUi5Yaml(rootPath, logger);
     if (!spaceGuid) {
         throw new Error('No space GUID (from config or ui5.yaml). Cannot load CF env options.');
     }
-    if (!node_fs_1.default.existsSync(mtaPath)) {
+    if (!fs.existsSync(mtaPath)) {
         throw new Error(`mta.yaml not found at "${mtaPath}". Cannot load CF env options.`);
     }
-    const mtaYaml = (0, adp_tooling_1.getYamlContent)(mtaPath);
-    const VCAP_SERVICES = await (0, adp_tooling_1.buildVcapServicesFromResources)(mtaYaml.resources, spaceGuid, logger);
+    const mtaYaml = getYamlContent(mtaPath);
+    const VCAP_SERVICES = await buildVcapServicesFromResources(mtaYaml.resources, spaceGuid, logger);
     return {
         VCAP_SERVICES,
         destinations: middlewareDestinations
@@ -130,14 +121,14 @@ async function loadEnvOptions(rootPath, effectiveOptions, logger) {
  * @param basExternalUrl - Optional BAS external URL; when set, used as the destination URL.
  * @returns True if destination was created or updated, false if no change needed.
  */
-function updateUi5ServerDestinationPort(effectiveOptions, actualPort, basExternalUrl) {
+export function updateUi5ServerDestinationPort(effectiveOptions, actualPort, basExternalUrl) {
     const newUrl = basExternalUrl ? basExternalUrl.href : `http://localhost:${actualPort}`;
-    let ui5ServerDest = effectiveOptions.destinations.find((d) => d.name === constants_1.UI5_SERVER_DESTINATION);
+    let ui5ServerDest = effectiveOptions.destinations.find((d) => d.name === UI5_SERVER_DESTINATION);
     if (!ui5ServerDest) {
-        ui5ServerDest = { name: constants_1.UI5_SERVER_DESTINATION, url: newUrl };
+        ui5ServerDest = { name: UI5_SERVER_DESTINATION, url: newUrl };
         effectiveOptions.destinations.push(ui5ServerDest);
         const envDestinations = JSON.parse(process.env.destinations ?? '[]');
-        envDestinations.push({ name: constants_1.UI5_SERVER_DESTINATION, url: newUrl });
+        envDestinations.push({ name: UI5_SERVER_DESTINATION, url: newUrl });
         process.env.destinations = JSON.stringify(envDestinations);
         return true;
     }
@@ -148,12 +139,12 @@ function updateUi5ServerDestinationPort(effectiveOptions, actualPort, basExterna
     }
     ui5ServerDest.url = newUrl;
     const envDestinations = JSON.parse(process.env.destinations ?? '[]');
-    const envUi5ServerDest = envDestinations.find((d) => d.name === constants_1.UI5_SERVER_DESTINATION);
+    const envUi5ServerDest = envDestinations.find((d) => d.name === UI5_SERVER_DESTINATION);
     if (envUi5ServerDest) {
         envUi5ServerDest.url = newUrl;
     }
     else {
-        envDestinations.push({ name: constants_1.UI5_SERVER_DESTINATION, url: newUrl });
+        envDestinations.push({ name: UI5_SERVER_DESTINATION, url: newUrl });
     }
     process.env.destinations = JSON.stringify(envDestinations);
     return true;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export type { BackendProxyMiddlewareCfConfig, ApprouterDestination, ApprouterExtension } from './types';
+export type { BackendProxyMiddlewareCfConfig, ApprouterDestination, ApprouterExtension } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=index.js.map

package/dist/middleware.d.ts

@@ -1,2 +1,16 @@
-export {};
+import type { MiddlewareParameters } from '@ui5/server';
+import type { RequestHandler } from 'express';
+import type { BackendProxyMiddlewareCfConfig } from './types.js';
+/**
+ * UI5 server middleware: runs `@sap/approuter` and proxies matching requests to it.
+ * Uses lazy initialization to detect the actual UI5 server port from the first request,
+ * enabling multi-instance support where hardcoded ports in ui5.yaml may differ from runtime.
+ *
+ * @param params - Middleware parameters from UI5 (options, middlewareUtil).
+ * @param params.options - Options containing configuration from ui5.yaml.
+ * @param params.middlewareUtil - UI5 middleware utilities (getProject, etc.).
+ * @returns Promise resolving to the proxy request handler.
+ */
+declare function backendProxyMiddlewareCf({ options, middlewareUtil }: MiddlewareParameters<BackendProxyMiddlewareCfConfig>): Promise<RequestHandler>;
+export default backendProxyMiddlewareCf;
 //# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.js

@@ -1,23 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_fs_1 = __importDefault(require("node:fs"));
-const dotenv_1 = __importDefault(require("dotenv"));
-const node_path_1 = __importDefault(require("node:path"));
-const logger_1 = require("@sap-ux/logger");
-const utils_1 = require("./utils");
-const proxy_1 = require("./proxy/proxy");
-const approuter_1 = require("./approuter/approuter");
-const extensions_1 = require("./approuter/extensions");
-const config_1 = require("./config/config");
-const xssecurity_1 = require("./platform/xssecurity");
-const bas_1 = require("./platform/bas");
-const routes_1 = require("./proxy/routes");
-const env_1 = require("./config/env");
-const tunnel_1 = require("./tunnel/tunnel");
-dotenv_1.default.config();
+import fs from 'node:fs';
+import dotenv from 'dotenv';
+import path from 'node:path';
+import { LogLevel, ToolsLogger, UI5ToolingTransport } from '@sap-ux/logger';
+import { nextFreePort } from './utils.js';
+import { createProxy } from './proxy/proxy.js';
+import { startApprouter } from './approuter/approuter.js';
+import { loadExtensions } from './approuter/extensions.js';
+import { mergeEffectiveOptions } from './config/config.js';
+import { updateXsuaaService } from './platform/xssecurity.js';
+import { fetchBasUrlTemplate, resolveBasExternalUrl } from './platform/bas.js';
+import { buildRouteEntries, loadAndPrepareXsappConfig } from './proxy/routes.js';
+import { loadEnvOptions, updateUi5ServerDestinationPort, getConnectivityProxyInfo, applyToProcessEnv } from './config/env.js';
+import { setupSshTunnel } from './tunnel/tunnel.js';
+dotenv.config();
 /**
  * UI5 server middleware: runs `@sap/approuter` and proxies matching requests to it.
  * Uses lazy initialization to detect the actual UI5 server port from the first request,
@@ -33,36 +28,36 @@ async function backendProxyMiddlewareCf({ options, middlewareUtil }) {
     if (!configuration) {
         throw new Error('Backend proxy middleware (CF) has no configuration.');
     }
-    const logger = new logger_1.ToolsLogger({
-        logLevel: configuration.debug ? logger_1.LogLevel.Debug : logger_1.LogLevel.Info,
-        transports: [new logger_1.UI5ToolingTransport({ moduleName: 'backend-proxy-middleware-cf' })]
+    const logger = new ToolsLogger({
+        logLevel: configuration.debug ? LogLevel.Debug : LogLevel.Info,
+        transports: [new UI5ToolingTransport({ moduleName: 'backend-proxy-middleware-cf' })]
     });
-    const effectiveOptions = (0, config_1.mergeEffectiveOptions)(configuration);
+    const effectiveOptions = mergeEffectiveOptions(configuration);
     process.env.WS_ALLOWED_ORIGINS = process.env.WS_ALLOWED_ORIGINS ?? JSON.stringify([{ host: 'localhost' }]);
     process.env.XS_APP_LOG_LEVEL = process.env.XS_APP_LOG_LEVEL ?? (effectiveOptions.debug ? 'DEBUG' : 'ERROR');
     const project = middlewareUtil.getProject();
     const rootPath = project.getRootPath() ?? process.cwd();
-    const xsappJsonPath = node_path_1.default.resolve(rootPath, effectiveOptions.xsappJsonPath);
-    if (!node_fs_1.default.existsSync(xsappJsonPath)) {
+    const xsappJsonPath = path.resolve(rootPath, effectiveOptions.xsappJsonPath);
+    if (!fs.existsSync(xsappJsonPath)) {
         throw new Error(`xs-app.json not found at "${xsappJsonPath}"`);
     }
-    const envOptions = await (0, env_1.loadEnvOptions)(rootPath, effectiveOptions, logger);
-    const connectivityInfo = (0, env_1.getConnectivityProxyInfo)(envOptions.VCAP_SERVICES);
-    (0, env_1.applyToProcessEnv)(envOptions);
-    await (0, xssecurity_1.updateXsuaaService)(rootPath, logger);
+    const envOptions = await loadEnvOptions(rootPath, effectiveOptions, logger);
+    const connectivityInfo = getConnectivityProxyInfo(envOptions.VCAP_SERVICES);
+    applyToProcessEnv(envOptions);
+    await updateXsuaaService(rootPath, logger);
     if (!effectiveOptions.disableSshTunnel && connectivityInfo) {
-        await (0, tunnel_1.setupSshTunnel)(rootPath, connectivityInfo, effectiveOptions, logger);
+        await setupSshTunnel(rootPath, connectivityInfo, effectiveOptions, logger);
     }
     const sourcePath = project.getSourcePath();
-    const xsappConfig = (0, routes_1.loadAndPrepareXsappConfig)({
+    const xsappConfig = loadAndPrepareXsappConfig({
         rootPath,
         xsappJsonPath,
         effectiveOptions,
         sourcePath,
         logger
     });
-    const { modules, routes: extensionsRoutes } = (0, extensions_1.loadExtensions)(rootPath, effectiveOptions.extensions, logger);
-    const port = await (0, utils_1.nextFreePort)(effectiveOptions.port, logger);
+    const { modules, routes: extensionsRoutes } = loadExtensions(rootPath, effectiveOptions.extensions, logger);
+    const port = await nextFreePort(effectiveOptions.port, logger);
     if (port !== effectiveOptions.port) {
         logger.info(`Port ${effectiveOptions.port} already in use. Using next free port: ${port} for the AppRouter.`);
     }
@@ -77,23 +72,23 @@ async function backendProxyMiddlewareCf({ options, middlewareUtil }) {
     if (logoutEndpoint) {
         customRoutes.push(logoutEndpoint);
     }
-    const basUrlTemplate = await (0, bas_1.fetchBasUrlTemplate)(logger);
+    const basUrlTemplate = await fetchBasUrlTemplate(logger);
     let initialized = false;
     let proxyMiddleware = null;
     return function lazyApprouterMiddleware(req, res, next) {
         if (!initialized) {
             try {
                 const actualPort = req.socket.localPort ?? 8080;
-                const basExternalUrl = (0, bas_1.resolveBasExternalUrl)(basUrlTemplate, actualPort);
+                const basExternalUrl = resolveBasExternalUrl(basUrlTemplate, actualPort);
                 if (basExternalUrl) {
                     logger.info(`BAS detected. External URL: ${basExternalUrl.href}`);
                 }
-                if ((0, env_1.updateUi5ServerDestinationPort)(effectiveOptions, actualPort, basExternalUrl)) {
+                if (updateUi5ServerDestinationPort(effectiveOptions, actualPort, basExternalUrl)) {
                     logger.info(`Auto-configured ui5-server destination to port ${actualPort}`);
                 }
-                const routes = (0, routes_1.buildRouteEntries)({ xsappConfig, effectiveOptions, logger });
-                (0, approuter_1.startApprouter)({ port, xsappConfig, rootPath, modules, logger });
-                proxyMiddleware = (0, proxy_1.createProxy)({ customRoutes, routes, baseUri, effectiveOptions, basExternalUrl }, logger);
+                const routes = buildRouteEntries({ xsappConfig, effectiveOptions, logger });
+                startApprouter({ port, xsappConfig, rootPath, modules, logger });
+                proxyMiddleware = createProxy({ customRoutes, routes, baseUri, effectiveOptions, basExternalUrl }, logger);
                 initialized = true;
             }
             catch (err) {
@@ -103,5 +98,5 @@ async function backendProxyMiddlewareCf({ options, middlewareUtil }) {
         proxyMiddleware(req, res, next);
     };
 }
-module.exports = backendProxyMiddlewareCf;
+export default backendProxyMiddlewareCf;
 //# sourceMappingURL=middleware.js.map

package/dist/platform/bas.js

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchBasUrlTemplate = fetchBasUrlTemplate;
-exports.resolveBasExternalUrl = resolveBasExternalUrl;
-const btp_utils_1 = require("@sap-ux/btp-utils");
+import { isAppStudio, exposePort } from '@sap-ux/btp-utils';
 /** Port placeholder used to obtain a BAS URL template before the actual port is known. */
 const BAS_PORT_PLACEHOLDER = 0;
 /**
@@ -12,11 +8,11 @@ const BAS_PORT_PLACEHOLDER = 0;
  * @param logger - Logger instance.
  * @returns URL template string, or empty string when not in BAS.
  */
-async function fetchBasUrlTemplate(logger) {
-    if (!(0, btp_utils_1.isAppStudio)()) {
+export async function fetchBasUrlTemplate(logger) {
+    if (!isAppStudio()) {
         return '';
     }
-    return (0, btp_utils_1.exposePort)(BAS_PORT_PLACEHOLDER, logger);
+    return exposePort(BAS_PORT_PLACEHOLDER, logger);
 }
 /**
  * Replace the placeholder port in a BAS URL template with the actual runtime port
@@ -26,7 +22,7 @@ async function fetchBasUrlTemplate(logger) {
  * @param actualPort - The real UI5 server port detected at runtime.
  * @returns Resolved URL, or undefined if the template is empty.
  */
-function resolveBasExternalUrl(basUrlTemplate, actualPort) {
+export function resolveBasExternalUrl(basUrlTemplate, actualPort) {
     if (!basUrlTemplate) {
         return undefined;
     }

package/dist/platform/xssecurity.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateXsuaaService = updateXsuaaService;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const adp_tooling_1 = require("@sap-ux/adp-tooling");
+import fs from 'node:fs';
+import path from 'node:path';
+import { getServicesForFile, updateServiceInstance } from '@sap-ux/adp-tooling';
 /**
  * Update the XSUAA service instance with oauth2-configuration redirect-uris
  * so that OAuth redirects work correctly in the BAS environment.
@@ -14,34 +8,34 @@ const adp_tooling_1 = require("@sap-ux/adp-tooling");
  * @param rootPath - Project root path (app folder; mta.yaml and xs-security.json are one level up).
  * @param logger - Logger instance.
  */
-async function updateXsuaaService(rootPath, logger) {
+export async function updateXsuaaService(rootPath, logger) {
     try {
-        const projectRoot = node_path_1.default.resolve(rootPath, '..');
-        const xsSecurityPath = node_path_1.default.resolve(projectRoot, 'xs-security.json');
-        const mtaPath = node_path_1.default.resolve(projectRoot, 'mta.yaml');
-        if (!node_fs_1.default.existsSync(xsSecurityPath)) {
+        const projectRoot = path.resolve(rootPath, '..');
+        const xsSecurityPath = path.resolve(projectRoot, 'xs-security.json');
+        const mtaPath = path.resolve(projectRoot, 'mta.yaml');
+        if (!fs.existsSync(xsSecurityPath)) {
             logger.warn(`xs-security.json not found at "${xsSecurityPath}", skipping XSUAA service update.`);
             return;
         }
-        if (!node_fs_1.default.existsSync(mtaPath)) {
+        if (!fs.existsSync(mtaPath)) {
             logger.warn(`mta.yaml not found at "${mtaPath}", skipping XSUAA service update.`);
             return;
         }
-        const xsSecurityContent = JSON.parse(node_fs_1.default.readFileSync(xsSecurityPath, 'utf-8'));
+        const xsSecurityContent = JSON.parse(fs.readFileSync(xsSecurityPath, 'utf-8'));
         const augmented = {
             ...xsSecurityContent,
             'oauth2-configuration': {
                 'redirect-uris': ['https://**.applicationstudio.cloud.sap/**', 'http://localhost:*/**']
             }
         };
-        const mtaServices = (0, adp_tooling_1.getServicesForFile)(mtaPath, logger);
+        const mtaServices = getServicesForFile(mtaPath, logger);
         const serviceInstanceName = mtaServices.find((s) => s.label === 'xsuaa')?.name;
         if (!serviceInstanceName) {
             logger.warn('No xsuaa service instance name found in mta.yaml, skipping XSUAA service update.');
             return;
         }
         logger.info(`Updating XSUAA service instance "${serviceInstanceName}" with BAS redirect-uris.`);
-        await (0, adp_tooling_1.updateServiceInstance)(serviceInstanceName, augmented);
+        await updateServiceInstance(serviceInstanceName, augmented);
         logger.info(`XSUAA service instance "${serviceInstanceName}" updated successfully.`);
     }
     catch (e) {

package/dist/proxy/proxy.d.ts

@@ -1,7 +1,7 @@
 import type { RequestHandler } from 'express';
 import { responseInterceptor } from 'http-proxy-middleware';
 import type { ToolsLogger } from '@sap-ux/logger';
-import type { CreateProxyOptions, EffectiveOptions, RouteEntry } from '../types';
+import type { CreateProxyOptions, EffectiveOptions, RouteEntry } from '../types.js';
 /**
  * Create the response interceptor for the proxy (content-type + URL rewriting).
  *

package/dist/proxy/proxy.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createResponseInterceptor = createResponseInterceptor;
-exports.createProxy = createProxy;
-const http_proxy_middleware_1 = require("http-proxy-middleware");
-const constants_1 = require("../config/constants");
-const utils_1 = require("./utils");
+import { createProxyMiddleware, responseInterceptor } from 'http-proxy-middleware';
+import { PROXY_MARKER_HEADER } from '../config/constants.js';
+import { createProxyFilter, getMimeInfo, getRequestOrigin, replaceUrl } from './utils.js';
 /**
  * Create the response interceptor for the proxy (content-type + URL rewriting).
  *
@@ -12,22 +8,22 @@ const utils_1 = require("./utils");
  * @param effectiveOptions - Merged options (rewriteContent, rewriteContentTypes, debug).
  * @returns The interceptor function to pass to responseInterceptor().
  */
-function createResponseInterceptor(routes, effectiveOptions) {
-    return (0, http_proxy_middleware_1.responseInterceptor)(async (responseBuffer, proxyRes, req, res) => {
+export function createResponseInterceptor(routes, effectiveOptions) {
+    return responseInterceptor(async (responseBuffer, proxyRes, req, res) => {
         const url = req.url ?? '';
         const pathname = /^[^?]*/.exec(url)?.[0] ?? url;
-        const { type, charset, contentType: ct } = (0, utils_1.getMimeInfo)(pathname, proxyRes.headers['content-type']);
+        const { type, charset, contentType: ct } = getMimeInfo(pathname, proxyRes.headers['content-type']);
         res.setHeader('content-type', ct);
         const route = routes.find((routeEntry) => routeEntry.sourcePattern.test(url));
         if (route?.path && route.url && effectiveOptions?.rewriteContentTypes?.includes(type?.toLowerCase() ?? '')) {
             const encoding = (charset ?? 'utf8');
             let data = responseBuffer.toString(encoding);
-            const referrer = req.headers.referrer ?? req.headers.referer ?? (0, utils_1.getRequestOrigin)(req);
+            const referrer = req.headers.referrer ?? req.headers.referer ?? getRequestOrigin(req);
             const referrerUrl = new URL(route.path, referrer).toString();
             const routeUrlParsed = new URL(route.url);
             const hostAndPath = `${routeUrlParsed.host}${routeUrlParsed.pathname}`;
-            data = (0, utils_1.replaceUrl)(data, `https://${hostAndPath}`, referrerUrl);
-            data = (0, utils_1.replaceUrl)(data, `http://${hostAndPath}`, referrerUrl);
+            data = replaceUrl(data, `https://${hostAndPath}`, referrerUrl);
+            data = replaceUrl(data, `http://${hostAndPath}`, referrerUrl);
             return Buffer.from(data);
         }
         return responseBuffer;
@@ -41,11 +37,11 @@ function createResponseInterceptor(routes, effectiveOptions) {
  * @param logger - Logger instance.
  * @returns Express request handler (the proxy middleware).
  */
-function createProxy(options, logger) {
+export function createProxy(options, logger) {
     const { customRoutes, routes, baseUri, effectiveOptions, basExternalUrl } = options;
     const intercept = createResponseInterceptor(routes, effectiveOptions);
-    const proxyFilter = (0, utils_1.createProxyFilter)(customRoutes, routes);
-    const proxyMiddleware = (0, http_proxy_middleware_1.createProxyMiddleware)({
+    const proxyFilter = createProxyFilter(customRoutes, routes);
+    const proxyMiddleware = createProxyMiddleware({
         logger: effectiveOptions.debug ? logger : undefined,
         target: baseUri,
         pathFilter: proxyFilter,
@@ -55,7 +51,7 @@ function createProxy(options, logger) {
         xfwd: true,
         on: {
             proxyReq: (proxyReq, req, res) => {
-                proxyReq.setHeader(constants_1.PROXY_MARKER_HEADER, '1');
+                proxyReq.setHeader(PROXY_MARKER_HEADER, '1');
                 const xfp = req.headers['x-forwarded-proto'];
                 if (typeof xfp === 'string' && xfp.includes(',')) {
                     const proto = xfp.split(',')[0];

package/dist/proxy/routes.d.ts

@@ -1,4 +1,4 @@
-import type { BuildRouteEntriesOptions, PrepareXsappConfigOptions, RouteEntry, XsappConfig } from '../types';
+import type { BuildRouteEntriesOptions, PrepareXsappConfigOptions, RouteEntry, XsappConfig } from '../types.js';
 /**
  * Load xs-app.json and prepare it for the approuter (filter routes, set auth, optionally append auth route).
  * Mutates and returns the config; does not build RouteEntry[].

package/dist/proxy/routes.js

@@ -1,13 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadAndPrepareXsappConfig = loadAndPrepareXsappConfig;
-exports.buildRouteEntries = buildRouteEntries;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const constants_1 = require("../config/constants");
+import fs from 'node:fs';
+import path from 'node:path';
+import { UI5_SERVER_DESTINATION } from '../config/constants.js';
 /**
  * Auth route for HTML pages - triggers XSUAA login.
  * Only this route is needed; /resources and /test-resources are handled
@@ -15,7 +8,7 @@ const constants_1 = require("../config/constants");
  */
 const UI5_SERVER_AUTH_ROUTE = {
     source: String.raw `^/(test|local)/.*\.html.*$`,
-    destination: constants_1.UI5_SERVER_DESTINATION,
+    destination: UI5_SERVER_DESTINATION,
     authenticationType: 'xsuaa'
 };
 /**
@@ -29,12 +22,12 @@ const UI5_SERVER_AUTH_ROUTE = {
  * @param logger - Logger for info/warn messages.
  */
 function injectAdpLiveReloadRoutes(routes, rootPath, logger) {
-    const manifestPath = node_path_1.default.join(rootPath, 'webapp', 'manifest.appdescr_variant');
-    if (!node_fs_1.default.existsSync(manifestPath)) {
+    const manifestPath = path.join(rootPath, 'webapp', 'manifest.appdescr_variant');
+    if (!fs.existsSync(manifestPath)) {
         return;
     }
     try {
-        const manifest = JSON.parse(node_fs_1.default.readFileSync(manifestPath, 'utf8'));
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
         const variantId = manifest.id.replaceAll('.', '_');
         routes.unshift({
             source: `^/changes/${variantId}/(.*)$`,
@@ -60,9 +53,9 @@ function injectAdpLiveReloadRoutes(routes, rootPath, logger) {
  * @param options - rootPath, xsappJsonPath, effectiveOptions, sourcePath.
  * @returns The loaded and mutated XsappConfig.
  */
-function loadAndPrepareXsappConfig(options) {
+export function loadAndPrepareXsappConfig(options) {
     const { rootPath, xsappJsonPath, effectiveOptions, sourcePath, logger } = options;
-    const xsappConfig = JSON.parse(node_fs_1.default.readFileSync(xsappJsonPath, 'utf8'));
+    const xsappConfig = JSON.parse(fs.readFileSync(xsappJsonPath, 'utf8'));
     const xsappRoutes = xsappConfig.routes ?? [];
     xsappConfig.routes = xsappRoutes.filter((route) => {
         if (route.service === 'html5-apps-repo-rt') {
@@ -84,7 +77,7 @@ function loadAndPrepareXsappConfig(options) {
     if (effectiveOptions.appendAuthRoute &&
         effectiveOptions.authenticationMethod &&
         effectiveOptions.authenticationMethod !== 'none') {
-        const relativeSourcePath = node_path_1.default.relative(rootPath, sourcePath);
+        const relativeSourcePath = path.relative(rootPath, sourcePath);
         xsappConfig.routes.push({
             source: String.raw `^/([^.]+\\.html?(?:\?.*)?)$`,
             localDir: relativeSourcePath,
@@ -112,7 +105,7 @@ function loadAndPrepareXsappConfig(options) {
  * @param options - xsappConfig, effectiveOptions, logger.
  * @returns Route entries for the proxy.
  */
-function buildRouteEntries(options) {
+export function buildRouteEntries(options) {
     const { xsappConfig, effectiveOptions, logger } = options;
     const routes = [];
     const destList = Array.isArray(effectiveOptions.destinations) ? effectiveOptions.destinations : [];

package/dist/proxy/utils.d.ts

@@ -1,5 +1,5 @@
 import type { IncomingMessage } from 'node:http';
-import type { MimeInfo, RouteEntry } from '../types';
+import type { MimeInfo, RouteEntry } from '../types.js';
 /**
  * Escape a string so it can be safely embedded in a RegExp.
  *

package/dist/proxy/utils.js

@@ -1,25 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeRegExp = escapeRegExp;
-exports.replaceUrl = replaceUrl;
-exports.createPathFilter = createPathFilter;
-exports.isRequestFromApprouter = isRequestFromApprouter;
-exports.createProxyFilter = createProxyFilter;
-exports.getRequestOrigin = getRequestOrigin;
-exports.getMimeInfo = getMimeInfo;
-const mime_types_1 = __importDefault(require("mime-types"));
-const content_type_1 = __importDefault(require("content-type"));
-const constants_1 = require("../config/constants");
+import mime from 'mime-types';
+import contentType from 'content-type';
+import { PROXY_MARKER_HEADER } from '../config/constants.js';
 /**
  * Escape a string so it can be safely embedded in a RegExp.
  *
  * @param value - Raw string.
  * @returns Regex-safe string with all metacharacters escaped.
  */
-function escapeRegExp(value) {
+export function escapeRegExp(value) {
     return value.replaceAll(/[-/\\^$*+?.()|[\]{}]/g, String.raw `\$&`);
 }
 /**
@@ -30,7 +18,7 @@ function escapeRegExp(value) {
  * @param newUrl - Replacement URL.
  * @returns Text with URLs replaced.
  */
-function replaceUrl(text, oldUrl, newUrl) {
+export function replaceUrl(text, oldUrl, newUrl) {
     const regex = new RegExp(escapeRegExp(oldUrl), 'gi');
     return text.replace(regex, newUrl);
 }
@@ -41,7 +29,7 @@ function replaceUrl(text, oldUrl, newUrl) {
  * @param routes - Route entries with compiled regex.
  * @returns Filter function (pathname) => boolean.
  */
-function createPathFilter(customRoutes, routes) {
+export function createPathFilter(customRoutes, routes) {
     const compiledCustomRoutes = customRoutes.map((route) => new RegExp(String.raw `^${escapeRegExp(route)}(\?.*)?$`));
     return (pathname) => {
         return (compiledCustomRoutes.some((customRoute) => customRoute.test(pathname)) ||
@@ -57,8 +45,8 @@ function createPathFilter(customRoutes, routes) {
  * @param req - Incoming request.
  * @returns True if request came from approuter.
  */
-function isRequestFromApprouter(req) {
-    return !!req.headers[constants_1.PROXY_MARKER_HEADER];
+export function isRequestFromApprouter(req) {
+    return !!req.headers[PROXY_MARKER_HEADER];
 }
 /**
  * Creates a proxy filter that checks both route matching and approuter origin.
@@ -68,7 +56,7 @@ function isRequestFromApprouter(req) {
  * @param routes - Route entries with compiled regex.
  * @returns Filter function (pathname, req) => boolean for http-proxy-middleware.
  */
-function createProxyFilter(customRoutes, routes) {
+export function createProxyFilter(customRoutes, routes) {
     const pathFilter = createPathFilter(customRoutes, routes);
     return (pathname, req) => {
         return !isRequestFromApprouter(req) && pathFilter(pathname);
@@ -82,7 +70,7 @@ function createProxyFilter(customRoutes, routes) {
  * @param req.baseUrl - Optional base URL path.
  * @returns Origin URL string.
  */
-function getRequestOrigin(req) {
+export function getRequestOrigin(req) {
     return `${String((req.headers['x-forwarded-proto'] ?? 'https').toString().split(',')[0])}://${req.headers['x-forwarded-host'] ?? ''}${req.baseUrl ?? ''}`;
 }
 /**
@@ -92,19 +80,19 @@ function getRequestOrigin(req) {
  * @param ctValue - Content-Type header value.
  * @returns MimeInfo object.
  */
-function getMimeInfo(pathname, ctValue) {
+export function getMimeInfo(pathname, ctValue) {
     if (ctValue) {
-        const parsed = content_type_1.default.parse(ctValue);
+        const parsed = contentType.parse(ctValue);
         const type = parsed.type ?? 'application/octet-stream';
-        const charset = parsed.parameters?.charset ?? mime_types_1.default.charset(type) ?? 'utf-8';
+        const charset = parsed.parameters?.charset ?? mime.charset(type) ?? 'utf-8';
         return {
             type,
             charset,
-            contentType: content_type_1.default.format({ type, parameters: parsed.parameters })
+            contentType: contentType.format({ type, parameters: parsed.parameters })
         };
     }
-    const type = mime_types_1.default.lookup(pathname) || 'application/octet-stream';
-    const charset = mime_types_1.default.charset(type) || 'utf-8';
+    const type = mime.lookup(pathname) || 'application/octet-stream';
+    const charset = mime.charset(type) || 'utf-8';
     return {
         type,
         charset,

package/dist/tunnel/destination-check.js

@@ -1,13 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasOnPremiseDestination = hasOnPremiseDestination;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const btp_utils_1 = require("@sap-ux/btp-utils");
-const adp_tooling_1 = require("@sap-ux/adp-tooling");
+import fs from 'node:fs';
+import path from 'node:path';
+import { DestinationProxyType } from '@sap-ux/btp-utils';
+import { getToken, getBtpDestinationConfig } from '@sap-ux/adp-tooling';
 /**
  * Extract unique destination names from the routes in webapp/xs-app.json.
  *
@@ -15,12 +9,12 @@ const adp_tooling_1 = require("@sap-ux/adp-tooling");
  * @returns Array of unique destination names, or empty array if no webapp/xs-app.json or no destinations.
  */
 function getWebappXsappDestinationNames(rootPath) {
-    const xsappPath = node_path_1.default.join(rootPath, 'webapp', 'xs-app.json');
-    if (!node_fs_1.default.existsSync(xsappPath)) {
+    const xsappPath = path.join(rootPath, 'webapp', 'xs-app.json');
+    if (!fs.existsSync(xsappPath)) {
         return [];
     }
     try {
-        const xsappConfig = JSON.parse(node_fs_1.default.readFileSync(xsappPath, 'utf8'));
+        const xsappConfig = JSON.parse(fs.readFileSync(xsappPath, 'utf8'));
         const names = new Set();
         for (const route of xsappConfig.routes ?? []) {
             if (route.destination) {
@@ -71,7 +65,7 @@ function getBtpDestinationServiceAuth() {
  * @param logger - Logger instance.
  * @returns True if an OnPremise destination is found; false otherwise.
  */
-async function hasOnPremiseDestination(rootPath, logger) {
+export async function hasOnPremiseDestination(rootPath, logger) {
     const destinationNames = getWebappXsappDestinationNames(rootPath);
     if (destinationNames.length === 0) {
         logger.debug('No webapp/xs-app.json or no destinations in routes, skipping OnPremise check.');
@@ -84,7 +78,7 @@ async function hasOnPremiseDestination(rootPath, logger) {
     }
     let token;
     try {
-        token = await (0, adp_tooling_1.getToken)(auth.uaa, logger);
+        token = await getToken(auth.uaa, logger);
     }
     catch (e) {
         const message = e instanceof Error ? e.message : String(e);
@@ -93,8 +87,8 @@ async function hasOnPremiseDestination(rootPath, logger) {
     }
     for (const name of destinationNames) {
         try {
-            const config = await (0, adp_tooling_1.getBtpDestinationConfig)(auth.uri, token, name, logger);
-            if (config?.ProxyType === btp_utils_1.DestinationProxyType.ON_PREMISE) {
+            const config = await getBtpDestinationConfig(auth.uri, token, name, logger);
+            if (config?.ProxyType === DestinationProxyType.ON_PREMISE) {
                 logger.info(`Destination "${name}" is OnPremise, SSH tunnel is needed.`);
                 return true;
             }

package/dist/tunnel/tunnel.d.ts

@@ -1,6 +1,6 @@
 import type { ChildProcess } from 'node:child_process';
 import type { ToolsLogger } from '@sap-ux/logger';
-import type { ConnectivityProxyInfo, SshTunnelOptions, EffectiveOptions } from '../types';
+import type { ConnectivityProxyInfo, SshTunnelOptions, EffectiveOptions } from '../types.js';
 /**
  * Start an SSH tunnel to the connectivity proxy if needed.
  * Skips if the port is already in use or if no connectivity service is present.

package/dist/tunnel/tunnel.js

@@ -1,14 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startSshTunnelIfNeeded = startSshTunnelIfNeeded;
-exports.setupSshTunnel = setupSshTunnel;
-const node_net_1 = __importDefault(require("node:net"));
-const node_child_process_1 = require("node:child_process");
-const adp_tooling_1 = require("@sap-ux/adp-tooling");
-const destination_check_1 = require("./destination-check");
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import { ensureTunnelAppExists, enableSshAndRestart, DEFAULT_TUNNEL_APP_NAME } from '@sap-ux/adp-tooling';
+import { hasOnPremiseDestination } from './destination-check.js';
 /**
  * Check if a port is already in use.
  *
@@ -17,7 +10,7 @@ const destination_check_1 = require("./destination-check");
  */
 function isPortInUse(port) {
     return new Promise((resolve) => {
-        const server = node_net_1.default.createServer();
+        const server = net.createServer();
         server.once('error', () => resolve(true));
         server.once('listening', () => {
             server.close(() => resolve(false));
@@ -40,7 +33,7 @@ function waitForPort(port, timeoutMs) {
                 resolve(false);
                 return;
             }
-            const socket = node_net_1.default.connect(port, '127.0.0.1');
+            const socket = net.connect(port, '127.0.0.1');
             socket.once('connect', () => {
                 socket.destroy();
                 resolve(true);
@@ -66,7 +59,7 @@ function waitForPort(port, timeoutMs) {
 function spawnSshTunnel(appName, localPort, remoteHost, remotePort, logger) {
     const tunnelArg = `${localPort}:${remoteHost}:${remotePort}`;
     logger.info(`Starting SSH tunnel: cf ssh ${appName} -N -T -L ${tunnelArg}`);
-    const child = (0, node_child_process_1.spawn)('cf', ['ssh', appName, '-N', '-T', '-L', tunnelArg], {
+    const child = spawn('cf', ['ssh', appName, '-N', '-T', '-L', tunnelArg], {
         stdio: 'pipe',
         shell: process.platform === 'win32'
     });
@@ -111,7 +104,7 @@ function registerCleanup(tunnelProcess, logger) {
  * @param options - Optional tunnel configuration.
  * @returns The SSH tunnel child process, or undefined if not started.
  */
-async function startSshTunnelIfNeeded(connectivityInfo, tunnelAppName, logger, options) {
+export async function startSshTunnelIfNeeded(connectivityInfo, tunnelAppName, logger, options) {
     try {
         const localPort = options?.localPort ?? connectivityInfo.port;
         if (await isPortInUse(localPort)) {
@@ -119,7 +112,7 @@ async function startSshTunnelIfNeeded(connectivityInfo, tunnelAppName, logger, o
             return undefined;
         }
         if (!options?.skipSshEnable) {
-            await (0, adp_tooling_1.enableSshAndRestart)(tunnelAppName, logger);
+            await enableSshAndRestart(tunnelAppName, logger);
         }
         const child = spawnSshTunnel(tunnelAppName, localPort, connectivityInfo.host, connectivityInfo.port, logger);
         registerCleanup(child, logger);
@@ -147,14 +140,14 @@ async function startSshTunnelIfNeeded(connectivityInfo, tunnelAppName, logger, o
  * @param effectiveOptions - Merged middleware options.
  * @param logger - Logger instance.
  */
-async function setupSshTunnel(rootPath, connectivityInfo, effectiveOptions, logger) {
-    const needsSshTunnel = await (0, destination_check_1.hasOnPremiseDestination)(rootPath, logger);
+export async function setupSshTunnel(rootPath, connectivityInfo, effectiveOptions, logger) {
+    const needsSshTunnel = await hasOnPremiseDestination(rootPath, logger);
     if (!needsSshTunnel) {
         logger.info('No OnPremise destination found in webapp/xs-app.json, skipping SSH tunnel setup.');
         return;
     }
-    const tunnelAppName = effectiveOptions.tunnelAppName ?? adp_tooling_1.DEFAULT_TUNNEL_APP_NAME;
-    await (0, adp_tooling_1.ensureTunnelAppExists)(tunnelAppName, logger);
+    const tunnelAppName = effectiveOptions.tunnelAppName ?? DEFAULT_TUNNEL_APP_NAME;
+    await ensureTunnelAppExists(tunnelAppName, logger);
     await startSshTunnelIfNeeded(connectivityInfo, tunnelAppName, logger, {
         localPort: effectiveOptions.tunnelLocalPort,
         skipSshEnable: effectiveOptions.skipSshEnable

package/dist/types.js

@@ -1,3 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};
 //# sourceMappingURL=types.js.map

package/dist/utils.js

@@ -1,10 +1,4 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nextFreePort = nextFreePort;
-const portfinder_1 = __importDefault(require("portfinder"));
+import portfinder from 'portfinder';
 /**
  * Returns the next free port starting from basePort.
  *
@@ -12,10 +6,10 @@ const portfinder_1 = __importDefault(require("portfinder"));
  * @param logger - Optional logger to warn if portfinder fails and basePort is used.
  * @returns A free port number.
  */
-async function nextFreePort(basePort, logger) {
+export async function nextFreePort(basePort, logger) {
     try {
-        portfinder_1.default.basePort = basePort;
-        return await portfinder_1.default.getPortPromise();
+        portfinder.basePort = basePort;
+        return await portfinder.getPortPromise();
     }
     catch {
         logger?.warn(`portfinder failed, using base port ${basePort}.`);

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@sap-ux/backend-proxy-middleware-cf",
   "description": "UI5 server middleware using @sap/approuter for CF-style destinations and xs-app.json",
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/SAP/open-ux-tools.git",
@@ -9,7 +10,7 @@
   "bugs": {
     "url": "https://github.com/SAP/open-ux-tools/issues?q=is%3Aopen+is%3Aissue+label%3Abug+label%3Abackend-proxy-middleware-cf"
   },
-  "version": "0.2.10",
+  "version": "0.3.0",
   "license": "Apache-2.0",
   "author": "@SAP/ux-tools-team",
   "main": "dist/index.js",
@@ -27,11 +28,12 @@
     "http-proxy-middleware": "3.0.5",
     "mime-types": "^2.1.35",
     "portfinder": "^1.0.32",
-    "@sap-ux/adp-tooling": "0.19.10",
-    "@sap-ux/btp-utils": "1.2.1",
-    "@sap-ux/logger": "0.9.0"
+    "@sap-ux/adp-tooling": "1.0.0",
+    "@sap-ux/btp-utils": "2.0.0",
+    "@sap-ux/logger": "1.0.0"
   },
   "devDependencies": {
+    "@jest/globals": "30.3.0",
     "@types/content-type": "^1.0.0",
     "@types/express": "4.17.21",
     "@types/http-proxy": "^1.17.5",
@@ -47,6 +49,6 @@
     "format": "prettier --write '**/*.{js,json,ts,yaml,yml}' --ignore-path ../../.prettierignore",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
-    "test": "jest --ci --forceExit --detectOpenHandles --colors"
+    "test": "cross-env NODE_OPTIONS='--experimental-vm-modules' jest --ci --forceExit --detectOpenHandles --colors"
   }
 }