@forge/tunnel 5.0.2-next.1 → 5.0.2-next.3

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @forge/tunnel
 
+## 5.0.2-next.3
+
+### Patch Changes
+
+- Updated dependencies [937db7a]
+  - @forge/cli-shared@4.0.1-next.2
+  - @forge/bundler@4.15.11-next.2
+
+## 5.0.2-next.2
+
+### Patch Changes
+
+- @forge/cli-shared@4.0.1-next.1
+- @forge/bundler@4.15.11-next.1
+
 ## 5.0.2-next.1
 
 ### Patch Changes

package/out/command/interactors/function-change-watcher.js

@@ -10,16 +10,15 @@ const runtime_1 = require("@forge/runtime");
 const util_1 = require("../../util");
 exports.MEMORY_LIMIT = 256;
 class LocalFunctionHost {
-    configFile;
-    logger;
-    snapshot;
-    createSandbox;
-    snapshotLogs = [];
     constructor(configFile, logger, snapshot, createSandbox) {
         this.configFile = configFile;
         this.logger = logger;
         this.snapshot = snapshot;
         this.createSandbox = createSandbox;
+        this.snapshotLogs = [];
+        this.onRuntimeLog = (event) => {
+            this.logger.info((0, util_1.formatRuntimeLog)(event));
+        };
     }
     async generateBundleFiles(bundle, withSnapshot) {
         await fs_1.promises.mkdir((0, path_1.dirname)(bundle.bundleFilePath), { recursive: true });
@@ -49,12 +48,13 @@ class LocalFunctionHost {
             this.snapshotLogs = [];
         }
         const bundles = Object.keys(bundledCode.output).map((bundlePath) => {
+            var _a;
             const sourceMapPath = `${bundlePath}.map`;
             return {
                 bundleFilePath: (0, path_1.resolve)(directory, bundlePath),
                 bundleFileContent: bundledCode.output[bundlePath],
                 bundleFileSourceMapPath: (0, path_1.resolve)(directory, sourceMapPath),
-                bundleFileSourceMap: bundledCode.sourceMap?.[sourceMapPath]
+                bundleFileSourceMap: (_a = bundledCode.sourceMap) === null || _a === void 0 ? void 0 : _a[sourceMapPath]
             };
         });
         const manifestFilePath = (0, path_1.resolve)(directory, cli_shared_1.manifestFileName);
@@ -84,9 +84,6 @@ class LocalFunctionHost {
     async stopWatching() {
         runtime_1.StaticInvocationEventEmitter.removeAllListeners();
     }
-    onRuntimeLog = (event) => {
-        this.logger.info((0, util_1.formatRuntimeLog)(event));
-    };
     async initializeSandboxes(srcPath, tunnelOptions) {
         try {
             const handlers = await this.configFile.getAppHandlers();

package/out/command/interactors/multi-compiler-watcher.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiCompilerWatcher = void 0;
 class MultiCompilerWatcher {
-    servers;
     constructor(servers) {
         this.servers = servers;
     }
@@ -15,18 +14,9 @@ class MultiCompilerWatcher {
             output: {}
         };
         for (const result of results) {
-            multiResult.output = {
-                ...multiResult.output,
-                ...result.output
-            };
-            multiResult.sourceMap = {
-                ...multiResult.sourceMap,
-                ...result.sourceMap
-            };
-            multiResult.metadata = {
-                ...multiResult.metadata,
-                ...result.metadata
-            };
+            multiResult.output = Object.assign(Object.assign({}, multiResult.output), result.output);
+            multiResult.sourceMap = Object.assign(Object.assign({}, multiResult.sourceMap), result.sourceMap);
+            multiResult.metadata = Object.assign(Object.assign({}, multiResult.metadata), result.metadata);
         }
         return multiResult;
     }

package/out/command/interactors/tunnel-interactor.js

@@ -7,9 +7,55 @@ const bundler_1 = require("@forge/bundler");
 const cli_shared_1 = require("@forge/cli-shared");
 const multi_compiler_watcher_1 = require("./multi-compiler-watcher");
 class TunnelInteractor {
-    logger;
     constructor(logger) {
         this.logger = logger;
+        this.watchApp = async (startTunnelResult, tunnelOptions = {}) => {
+            const { localPort, inspectorAddress, reloadSandboxes, devServers } = startTunnelResult;
+            if (inspectorAddress) {
+                this.logger.info(cli_shared_1.Text.tunnel.startedInspector(inspectorAddress));
+            }
+            const onBundlingStart = async () => {
+                try {
+                    this.logger.info('');
+                    this.logger.info(cli_shared_1.Text.bundle.detectedChanges);
+                    await (0, bundler_1.runLinter)();
+                    this.logger.info(cli_shared_1.Text.tunnel.preBundleTask(cli_shared_1.Text.tunnel.bundlingHeader));
+                }
+                catch (err) {
+                    throw err;
+                }
+            };
+            const onBundlingFinish = async (err, output) => {
+                if (err) {
+                    this.logger.error(err);
+                    return;
+                }
+                if (output) {
+                    await reloadSandboxes(output, tunnelOptions);
+                }
+                this.logger.info('');
+                this.logger.info(cli_shared_1.Text.tunnel.startedServer(localPort, this.logger.debugEnabled) + '\n');
+            };
+            if (devServers.length > 0) {
+                const multiCompiler = new multi_compiler_watcher_1.MultiCompilerWatcher(devServers);
+                await (0, bundler_1.runLinter)();
+                this.logger.info(cli_shared_1.Text.tunnel.preBundleTask(cli_shared_1.Text.tunnel.bundlingHeader));
+                try {
+                    const output = await multiCompiler.compileAndWatch({
+                        onChange: {
+                            onBuildWillStart: onBundlingStart,
+                            onBuildFinished: onBundlingFinish
+                        }
+                    });
+                    await reloadSandboxes(output, tunnelOptions);
+                    this.logger.info('');
+                    this.logger.info(cli_shared_1.Text.tunnel.startedServer(localPort, this.logger.debugEnabled) + '\n');
+                }
+                catch (_) {
+                }
+                return multiCompiler;
+            }
+        };
     }
     handleUserExitEvent(stopFunction, bundleMonitor) {
         return new Promise((resolve, reject) => {
@@ -42,52 +88,5 @@ class TunnelInteractor {
             process.on('SIGTERM', tunnelCleanupListener);
         });
     }
-    watchApp = async (startTunnelResult, tunnelOptions = {}) => {
-        const { localPort, inspectorAddress, reloadSandboxes, devServers } = startTunnelResult;
-        if (inspectorAddress) {
-            this.logger.info(cli_shared_1.Text.tunnel.startedInspector(inspectorAddress));
-        }
-        const onBundlingStart = async () => {
-            try {
-                this.logger.info('');
-                this.logger.info(cli_shared_1.Text.bundle.detectedChanges);
-                await (0, bundler_1.runLinter)();
-                this.logger.info(cli_shared_1.Text.tunnel.preBundleTask(cli_shared_1.Text.tunnel.bundlingHeader));
-            }
-            catch (err) {
-                throw err;
-            }
-        };
-        const onBundlingFinish = async (err, output) => {
-            if (err) {
-                this.logger.error(err);
-                return;
-            }
-            if (output) {
-                await reloadSandboxes(output, tunnelOptions);
-            }
-            this.logger.info('');
-            this.logger.info(cli_shared_1.Text.tunnel.startedServer(localPort, this.logger.debugEnabled) + '\n');
-        };
-        if (devServers.length > 0) {
-            const multiCompiler = new multi_compiler_watcher_1.MultiCompilerWatcher(devServers);
-            await (0, bundler_1.runLinter)();
-            this.logger.info(cli_shared_1.Text.tunnel.preBundleTask(cli_shared_1.Text.tunnel.bundlingHeader));
-            try {
-                const output = await multiCompiler.compileAndWatch({
-                    onChange: {
-                        onBuildWillStart: onBundlingStart,
-                        onBuildFinished: onBundlingFinish
-                    }
-                });
-                await reloadSandboxes(output, tunnelOptions);
-                this.logger.info('');
-                this.logger.info(cli_shared_1.Text.tunnel.startedServer(localPort, this.logger.debugEnabled) + '\n');
-            }
-            catch (_) {
-            }
-            return multiCompiler;
-        }
-    };
 }
 exports.TunnelInteractor = TunnelInteractor;

package/out/command/start-tunnel-command.js

@@ -8,16 +8,6 @@ const node_cache_1 = tslib_1.__importDefault(require("node-cache"));
 const servers_1 = require("../servers");
 const index_1 = require("../index");
 class StartTunnelCommand {
-    getAppConfig;
-    devServer;
-    tunnelFactory;
-    tunnelClient;
-    functionHost;
-    inspector;
-    logger;
-    configFile;
-    tunnelServers = {};
-    cspReporterServer;
     constructor(getAppConfig, devServer, tunnelFactory, tunnelClient, functionHost, inspector, logger, configFile) {
         this.getAppConfig = getAppConfig;
         this.devServer = devServer;
@@ -27,51 +17,44 @@ class StartTunnelCommand {
         this.inspector = inspector;
         this.logger = logger;
         this.configFile = configFile;
-    }
-    stopServices = async (appId, environmentKey) => {
-        await Promise.all([
-            this.functionHost.stopWatching(),
-            this.tunnelClient.unregisterTunnels(appId, environmentKey),
-            this.tunnelFactory.closeTunnel(),
-            this.devServer.stop(),
-            this.inspector.stopServer(),
-            ...Object.values(this.tunnelServers).map((server) => server.stop()),
-            this.cspReporterServer?.stop()
-        ]);
-    };
-    startFaaSTunnelServer = async ({ port, tunnelConfigPath }) => {
-        const { permissions = {}, remotes = [] } = await this.configFile.readConfig();
-        const serverInfo = await this.devServer.start(port, permissions, remotes);
-        const faasTunnelUrl = await this.tunnelFactory.establishTunnel({ port: serverInfo.port, tunnelConfigPath });
-        return {
-            ...serverInfo,
-            tunnelUrl: faasTunnelUrl
+        this.tunnelServers = {};
+        this.stopServices = async (appId, environmentKey) => {
+            var _a;
+            await Promise.all([
+                this.functionHost.stopWatching(),
+                this.tunnelClient.unregisterTunnels(appId, environmentKey),
+                this.tunnelFactory.closeTunnel(),
+                this.devServer.stop(),
+                this.inspector.stopServer(),
+                ...Object.values(this.tunnelServers).map((server) => server.stop()),
+                (_a = this.cspReporterServer) === null || _a === void 0 ? void 0 : _a.stop()
+            ]);
+        };
+        this.startFaaSTunnelServer = async ({ port, tunnelConfigPath }) => {
+            const { permissions = {}, remotes = [] } = await this.configFile.readConfig();
+            const serverInfo = await this.devServer.start(port, permissions, remotes);
+            const faasTunnelUrl = await this.tunnelFactory.establishTunnel({ port: serverInfo.port, tunnelConfigPath });
+            return Object.assign(Object.assign({}, serverInfo), { tunnelUrl: faasTunnelUrl });
         };
-    };
-    startResourceBasedTunnelsServers = async (resourceDetails, options) => {
-        const portMap = options.resourcePortMap ?? JSON.parse(process.env.RESOURCE_PORT_MAP ?? '{}');
-        const { permissions = {}, remotes = [] } = await this.configFile.readConfig();
-        const cspReporterPort = parseInt(process.env.CSP_REPORTER_PORT ?? '4000', 10);
-        if (resourceDetails.length === 0)
-            return [];
-        this.cspReporterServer = new servers_1.CspReporterServer(cspReporterPort, this.logger, new node_cache_1.default());
-        await this.cspReporterServer.start();
-        return await Promise.all(resourceDetails.map(async (rd) => {
-            const { key, resourceType } = rd;
-            const port = portMap[key];
-            const tunnelServer = resourceType === 'nativeUI' ? servers_1.NativeUITunnelServer : servers_1.CustomUITunnelServer;
-            this.tunnelServers[key] = new tunnelServer({
-                ...rd,
-                port,
-                host: options.host,
-                logger: this.logger,
-                cspReporterServerPort: cspReporterPort,
-                permissions,
-                remotes
-            });
-            return this.tunnelServers[key].start();
-        }));
-    };
+        this.startResourceBasedTunnelsServers = async (resourceDetails, options) => {
+            var _a, _b, _c;
+            const portMap = (_a = options.resourcePortMap) !== null && _a !== void 0 ? _a : JSON.parse((_b = process.env.RESOURCE_PORT_MAP) !== null && _b !== void 0 ? _b : '{}');
+            const { permissions = {}, remotes = [] } = await this.configFile.readConfig();
+            const cspReporterPort = parseInt((_c = process.env.CSP_REPORTER_PORT) !== null && _c !== void 0 ? _c : '4000', 10);
+            if (resourceDetails.length === 0)
+                return [];
+            this.cspReporterServer = new servers_1.CspReporterServer(cspReporterPort, this.logger, new node_cache_1.default());
+            await this.cspReporterServer.start();
+            return await Promise.all(resourceDetails.map(async (rd) => {
+                const { key, resourceType } = rd;
+                const port = portMap[key];
+                const tunnelServer = resourceType === 'nativeUI' ? servers_1.NativeUITunnelServer : servers_1.CustomUITunnelServer;
+                this.tunnelServers[key] = new tunnelServer(Object.assign(Object.assign({}, rd), { port, host: options.host, logger: this.logger, cspReporterServerPort: cspReporterPort, permissions,
+                    remotes }));
+                return this.tunnelServers[key].start();
+            }));
+        };
+    }
     async execute(options) {
         const { id: appId } = await this.getAppConfig();
         const { port, environmentKey } = options;
@@ -116,7 +99,7 @@ class StartTunnelCommand {
             try {
                 await this.stopServices(appId, environmentKey);
             }
-            catch { }
+            catch (_a) { }
             throw e;
         }
     }

package/out/graphql/tunnel-graphql-client.js

@@ -14,7 +14,6 @@ class DeleteAppTunnelError extends cli_shared_1.GraphQlMutationError {
     }
 }
 class TunnelGraphqlClient {
-    graphqlClient;
     constructor(graphqlClient) {
         this.graphqlClient = graphqlClient;
     }

package/out/sandbox/node-sandbox.js

@@ -9,9 +9,6 @@ const uuid_1 = require("uuid");
 const runtime_1 = require("@forge/runtime");
 const RUNNER = (0, path_1.join)(__dirname, '..', '..', 'out', 'sandbox', 'sandbox-runner.js');
 class NodeSandbox {
-    name;
-    process;
-    callbacks;
     constructor({ appPath, modName, handler, debugPort }) {
         this.name = `${modName}.${handler}`;
         const fileName = `${appPath}/${modName}.cjs`;
@@ -28,9 +25,10 @@ class NodeSandbox {
             this.handleOutput(message);
         });
         this.process.on('message', (message) => {
+            var _a;
             const requestId = message.requestId;
             const result = message.result;
-            this.callbacks.get(requestId)?.(result);
+            (_a = this.callbacks.get(requestId)) === null || _a === void 0 ? void 0 : _a(result);
         });
     }
     handleOutput(output) {

package/out/sandbox/sandbox-runner.js

@@ -3,7 +3,8 @@ const [_nodeBinary, _thisScript, fileName, handlerName] = process.argv;
 global.__forge_tunnel__ = true;
 const handler = require(fileName)[handlerName];
 process.on('message', async ({ lambdaEvent, lambdaContext }) => {
+    var _a;
     const requestId = lambdaContext.awsRequestId;
     const result = await handler(lambdaEvent, lambdaContext);
-    process.send?.({ requestId, result });
+    (_a = process.send) === null || _a === void 0 ? void 0 : _a.call(process, { requestId, result });
 });

package/out/servers/csp-reporter-server.js

@@ -5,12 +5,6 @@ const tslib_1 = require("tslib");
 const express_1 = tslib_1.__importDefault(require("express"));
 const cli_shared_1 = require("@forge/cli-shared");
 class CspReporterServer {
-    port;
-    logger;
-    cache;
-    app;
-    server;
-    static TTL_IN_SECONDS = 30;
     constructor(port, logger, cache) {
         this.port = port;
         this.logger = logger;
@@ -41,8 +35,10 @@ class CspReporterServer {
     }
     async stop() {
         return new Promise((resolve, reject) => {
-            this.server?.close((err) => (err ? reject(err) : resolve()));
+            var _a;
+            (_a = this.server) === null || _a === void 0 ? void 0 : _a.close((err) => (err ? reject(err) : resolve()));
         });
     }
 }
 exports.CspReporterServer = CspReporterServer;
+CspReporterServer.TTL_IN_SECONDS = 30;

package/out/servers/custom-ui-tunnel-server.js

@@ -14,19 +14,15 @@ var ConnectionErrorCode;
     ConnectionErrorCode["REFUSED"] = "ECONNREFUSED";
 })(ConnectionErrorCode || (ConnectionErrorCode = {}));
 class CustomUITunnelServer extends resource_tunnel_server_1.ResourceTunnelServer {
-    tunnelArgs;
-    app;
-    server;
-    proxy;
-    socket;
     constructor(tunnelArgs) {
+        var _a, _b;
         super(tunnelArgs);
         this.tunnelArgs = tunnelArgs;
         const { tunnel, permissions, remotes } = tunnelArgs;
         this.app = (0, express_1.default)();
         this.app.use(this.getCustomUIHtmlTransformMiddleware(permissions, remotes));
         if (tunnel) {
-            net_1.default.setDefaultAutoSelectFamily?.(true);
+            (_b = (_a = net_1.default).setDefaultAutoSelectFamily) === null || _b === void 0 ? void 0 : _b.call(_a, true);
             const { port: tunnelPort } = tunnel;
             this.proxy = (0, http_proxy_middleware_1.createProxyMiddleware)({
                 target: `http://${this.tunnelArgs.host}:${tunnelPort}`,
@@ -84,7 +80,7 @@ class CustomUITunnelServer extends resource_tunnel_server_1.ResourceTunnelServer
         return this.app;
     }
     handleProxyDestinationNotStarted(err, reqUrl, res, tunnelPort) {
-        if (err?.code !== ConnectionErrorCode.REFUSED || (reqUrl !== '/' && reqUrl !== 'index.html')) {
+        if ((err === null || err === void 0 ? void 0 : err.code) !== ConnectionErrorCode.REFUSED || (reqUrl !== '/' && reqUrl !== 'index.html')) {
             this.logger.error(err);
             return;
         }
@@ -95,8 +91,9 @@ class CustomUITunnelServer extends resource_tunnel_server_1.ResourceTunnelServer
         res.end(cli_shared_1.Text.tunnel.error.serverNotStartedOnPort(tunnelPort));
     }
     handleWebsocketUpgrade(req, socket, head) {
+        var _a;
         this.socket = socket;
-        if (this.proxy?.upgrade) {
+        if ((_a = this.proxy) === null || _a === void 0 ? void 0 : _a.upgrade) {
             return this.proxy.upgrade(req, socket, head);
         }
     }

package/out/servers/dev-server.js

@@ -19,19 +19,44 @@ async function stopServer(server) {
 }
 exports.stopServer = stopServer;
 class LocalDevelopmentServer {
-    invocationService;
-    logger;
-    configFile;
-    fileSystemReader;
-    app;
-    httpServer;
-    permissions;
-    remotes;
     constructor(invocationService, logger, configFile, fileSystemReader) {
         this.invocationService = invocationService;
         this.logger = logger;
         this.configFile = configFile;
         this.fileSystemReader = fileSystemReader;
+        this.handleInvocation = async (req, res) => {
+            var _a, _b, _c, _d, _e, _f;
+            const request = req.body;
+            const envVars = (0, runtime_1.getUserVars)();
+            (_a = request.variables) === null || _a === void 0 ? void 0 : _a.forEach((item) => {
+                if (!envVars.find((i) => i.key === item.key)) {
+                    envVars.push(item);
+                }
+            });
+            request.variables = [...envVars].sort((a, b) => a.key.localeCompare(b.key));
+            const allowList = (_f = (_e = (_d = (_c = (_b = this.permissions) === null || _b === void 0 ? void 0 : _b.external) === null || _c === void 0 ? void 0 : _c.fetch) === null || _d === void 0 ? void 0 : _d.backend) === null || _e === void 0 ? void 0 : _e.map((item) => {
+                var _a, _b;
+                if (typeof item === 'string')
+                    return item;
+                return (_b = (_a = this.remotes) === null || _a === void 0 ? void 0 : _a.find((remote) => remote.key === item.remote)) === null || _b === void 0 ? void 0 : _b.baseUrl;
+            }).filter((item) => typeof item === 'string')) !== null && _f !== void 0 ? _f : undefined;
+            request._meta = Object.assign(Object.assign({}, request._meta), { fetchAllowList: allowList });
+            try {
+                const invokeResults = await this.invocationService.invoke(request.handler, request);
+                if ((await this.configFile.runtimeType()) === cli_shared_1.RuntimeType.nodejs && !invokeResults.success) {
+                    return res.status(500).send(invokeResults.error);
+                }
+                res.json(invokeResults);
+            }
+            catch (error) {
+                try {
+                    res.status(500).send((0, util_1.toLambdaError)(error));
+                }
+                catch (e) {
+                    this.logger.error(e);
+                }
+            }
+        };
         this.app = (0, express_1.default)();
         this.app.use(express_1.default.json({ limit: '6mb' }));
         this.app.post(`/:fnKey`, this.handleInvocation);
@@ -96,41 +121,5 @@ class LocalDevelopmentServer {
     getApp() {
         return this.app;
     }
-    handleInvocation = async (req, res) => {
-        const request = req.body;
-        const envVars = (0, runtime_1.getUserVars)();
-        request.variables?.forEach((item) => {
-            if (!envVars.find((i) => i.key === item.key)) {
-                envVars.push(item);
-            }
-        });
-        request.variables = [...envVars].sort((a, b) => a.key.localeCompare(b.key));
-        const allowList = this.permissions?.external?.fetch?.backend
-            ?.map((item) => {
-            if (typeof item === 'string')
-                return item;
-            return this.remotes?.find((remote) => remote.key === item.remote)?.baseUrl;
-        })
-            .filter((item) => typeof item === 'string') ?? undefined;
-        request._meta = {
-            ...request._meta,
-            fetchAllowList: allowList
-        };
-        try {
-            const invokeResults = await this.invocationService.invoke(request.handler, request);
-            if ((await this.configFile.runtimeType()) === cli_shared_1.RuntimeType.nodejs && !invokeResults.success) {
-                return res.status(500).send(invokeResults.error);
-            }
-            res.json(invokeResults);
-        }
-        catch (error) {
-            try {
-                res.status(500).send((0, util_1.toLambdaError)(error));
-            }
-            catch (e) {
-                this.logger.error(e);
-            }
-        }
-    };
 }
 exports.LocalDevelopmentServer = LocalDevelopmentServer;

package/out/servers/native-ui-tunnel-server.js

@@ -8,26 +8,19 @@ const resource_tunnel_server_1 = require("./resource-tunnel-server");
 const cli_shared_1 = require("@forge/cli-shared");
 const url_1 = require("url");
 class NativeUITunnelServer extends resource_tunnel_server_1.ResourceTunnelServer {
-    tunnelArgs;
-    server;
     constructor(tunnelArgs) {
         super(tunnelArgs);
         this.tunnelArgs = tunnelArgs;
         const { key, path, port, permissions, remotes } = tunnelArgs;
         const entrypoint = { name: key, path, functions: [] };
         const config = (0, bundler_1.getNativeUiBuildConfig)([entrypoint]);
-        const compiler = (0, bundler_1.getCompiler)({
-            ...config,
-            infrastructureLogging: {
+        const compiler = (0, bundler_1.getCompiler)(Object.assign(Object.assign({}, config), { infrastructureLogging: {
                 level: 'error'
-            },
-            stats: 'errors-only',
-            watchOptions: {
+            }, stats: 'errors-only', watchOptions: {
                 aggregateTimeout: 200,
                 poll: 1000,
                 ignored: '**/node_modules'
-            }
-        });
+            } }));
         this.server = new webpack_dev_server_1.default({
             port,
             host: process.env.FORGE_DEV_TUNNEL ? 'localhost' : '0.0.0.0',

package/out/servers/resource-tunnel-server.js

@@ -5,12 +5,31 @@ const cli_shared_1 = require("@forge/cli-shared");
 const csp_1 = require("@forge/csp");
 const express_intercept_1 = require("express-intercept");
 class ResourceTunnelServer {
-    port;
-    key;
-    path;
-    logger;
-    cspReporterServerPort;
     constructor({ port, key, path, cspReporterServerPort, logger }) {
+        this.getCspHeader = (existingCsp) => new csp_1.CSPInjectionService()
+            .getInjectableCSP({
+            existingCSPDetails: existingCsp,
+            microsEnv: (0, cli_shared_1.getEnvironment)(cli_shared_1.CDNEnvironments),
+            tunnelCSPReporterUri: `http://localhost:${this.cspReporterServerPort}`
+        })
+            .join('; ');
+        this.injectGlobalBridgeScript = (htmlContent) => new cli_shared_1.BridgeScriptService().injectBridgeCore(htmlContent, () => {
+            throw new Error('Malformed HTML document');
+        });
+        this.injectIframeResizerScript = (htmlContent) => new cli_shared_1.IframeResizerScriptService().injectIframeResizer(htmlContent, () => {
+            throw new Error('Malformed HTML document');
+        });
+        this.getCustomUIHtmlTransformMiddleware = (permissions, remotes) => (0, express_intercept_1.responseHandler)()
+            .if((res) => /html/i.test(res.get('content-type')))
+            .replaceBuffer((body, _, res) => {
+            if (!res)
+                return body;
+            const htmlContentWithIframeResizerScript = this.injectIframeResizerScript(body);
+            const htmlContentWithBridgeScript = this.injectGlobalBridgeScript(htmlContentWithIframeResizerScript);
+            const cspDetails = new csp_1.CSPProcessingService({ info: () => { } }).getCspDetails(htmlContentWithBridgeScript, ResourceTunnelServer.transformPermissionsWithRemotes(permissions, remotes));
+            res.setHeader('Content-Security-Policy', this.getCspHeader(cspDetails));
+            return htmlContentWithBridgeScript;
+        });
         this.port = port;
         this.key = key;
         this.path = path;
@@ -18,43 +37,19 @@ class ResourceTunnelServer {
         this.cspReporterServerPort = cspReporterServerPort;
     }
     static transformPermissionsWithRemotes(permissions, remotes) {
-        const client = permissions.external?.fetch?.client
-            ?.map((item) => {
+        var _a, _b, _c, _d, _e;
+        const client = (_d = (_c = (_b = (_a = permissions.external) === null || _a === void 0 ? void 0 : _a.fetch) === null || _b === void 0 ? void 0 : _b.client) === null || _c === void 0 ? void 0 : _c.map((item) => {
+            var _a;
             if (typeof item === 'string')
                 return item;
-            return remotes?.find((remote) => remote.key === item.remote)?.baseUrl;
-        })
-            .filter((item) => typeof item === 'string') ?? undefined;
-        return { ...permissions, external: { ...permissions.external, fetch: { ...permissions.external?.fetch, client } } };
+            return (_a = remotes === null || remotes === void 0 ? void 0 : remotes.find((remote) => remote.key === item.remote)) === null || _a === void 0 ? void 0 : _a.baseUrl;
+        }).filter((item) => typeof item === 'string')) !== null && _d !== void 0 ? _d : undefined;
+        return Object.assign(Object.assign({}, permissions), { external: Object.assign(Object.assign({}, permissions.external), { fetch: Object.assign(Object.assign({}, (_e = permissions.external) === null || _e === void 0 ? void 0 : _e.fetch), { client }) }) });
     }
     logFileServed(reqUrl, textDecorator) {
         if (reqUrl !== '/' && reqUrl !== '/index.html')
             return;
         this.logger.info(cli_shared_1.LogColor.trace(textDecorator('index.html')));
     }
-    getCspHeader = (existingCsp) => new csp_1.CSPInjectionService()
-        .getInjectableCSP({
-        existingCSPDetails: existingCsp,
-        microsEnv: (0, cli_shared_1.getEnvironment)(cli_shared_1.CDNEnvironments),
-        tunnelCSPReporterUri: `http://localhost:${this.cspReporterServerPort}`
-    })
-        .join('; ');
-    injectGlobalBridgeScript = (htmlContent) => new cli_shared_1.BridgeScriptService().injectBridgeCore(htmlContent, () => {
-        throw new Error('Malformed HTML document');
-    });
-    injectIframeResizerScript = (htmlContent) => new cli_shared_1.IframeResizerScriptService().injectIframeResizer(htmlContent, () => {
-        throw new Error('Malformed HTML document');
-    });
-    getCustomUIHtmlTransformMiddleware = (permissions, remotes) => (0, express_intercept_1.responseHandler)()
-        .if((res) => /html/i.test(res.get('content-type')))
-        .replaceBuffer((body, _, res) => {
-        if (!res)
-            return body;
-        const htmlContentWithIframeResizerScript = this.injectIframeResizerScript(body);
-        const htmlContentWithBridgeScript = this.injectGlobalBridgeScript(htmlContentWithIframeResizerScript);
-        const cspDetails = new csp_1.CSPProcessingService({ info: () => { } }).getCspDetails(htmlContentWithBridgeScript, ResourceTunnelServer.transformPermissionsWithRemotes(permissions, remotes));
-        res.setHeader('Content-Security-Policy', this.getCspHeader(cspDetails));
-        return htmlContentWithBridgeScript;
-    });
 }
 exports.ResourceTunnelServer = ResourceTunnelServer;

package/out/services/create-tunnel-service.js

@@ -34,8 +34,6 @@ class NgrokError extends cli_shared_1.BaseError {
 }
 exports.NgrokError = NgrokError;
 class NgrokCreateTunnelService {
-    logger;
-    endpoint;
     constructor(logger) {
         this.logger = logger;
     }
@@ -45,7 +43,7 @@ class NgrokCreateTunnelService {
         try {
             const options = {
                 addr: port,
-                configPath: tunnelConfigPath ?? defaultConfigPath,
+                configPath: tunnelConfigPath !== null && tunnelConfigPath !== void 0 ? tunnelConfigPath : defaultConfigPath,
                 onStatusChange: (status) => {
                     this.logger.debug(cli_shared_1.Text.tunnel.tunnelStatusChange(status));
                 },
@@ -56,7 +54,7 @@ class NgrokCreateTunnelService {
                         try {
                             ngrokErrorMessage = JSON.parse(ngrokErrorMessage);
                         }
-                        catch { }
+                        catch (_a) { }
                     }
                     this.logger.debug(data);
                 }
@@ -75,7 +73,7 @@ class NgrokCreateTunnelService {
                 await ngrok.disconnect();
                 await ngrok.kill();
             }
-            catch { }
+            catch (_a) { }
             this.endpoint = undefined;
         }
     }

package/out/services/local-invocation-service.js

@@ -8,15 +8,13 @@ const runtime_1 = require("@forge/runtime");
 const cli_shared_1 = require("@forge/cli-shared");
 const DEFAULT_INVOCATION_TIMEOUT = 25;
 class LocalInvocationService {
-    configFile;
-    logger;
-    inspector;
     constructor(configFile, logger, inspector) {
         this.configFile = configFile;
         this.logger = logger;
         this.inspector = inspector;
     }
     async invoke(handler, request) {
+        var _a;
         this.logger.info('');
         this.logger.info((0, util_1.formatInvocation)(handler, request));
         const sandbox = util_1.SandboxesContainer.get()[handler];
@@ -40,9 +38,9 @@ class LocalInvocationService {
             variables.push({ key: 'FUNCTION_IS_SNAPSHOTTED', value: isSnapshotEnabled.toString(), secure: false });
         }
         const requestId = (0, util_1.getRequestId)(request, (0, uuid_1.v4)());
-        const timeout = request._meta.timeout ?? DEFAULT_INVOCATION_TIMEOUT;
+        const timeout = (_a = request._meta.timeout) !== null && _a !== void 0 ? _a : DEFAULT_INVOCATION_TIMEOUT;
         const xenInvocationRequest = (0, runtime_1.xenInvocationRequestFactory)({
-            request: { ...request, variables },
+            request: Object.assign(Object.assign({}, request), { variables }),
             ctx: { requestId, traceId: requestId, timeout }
         });
         const invocationLimits = (0, runtime_1.perInvocationLimitsTrackerFactory)(xenInvocationRequest);
@@ -60,11 +58,11 @@ class LocalInvocationService {
         LocalInvocationService.printMetrics(reportMetrics, metrics, this.logger);
         return reportMetrics ? { body, metrics, success, error } : body;
     }
-    static INTERNAL_METRICS = ['execute.setup-request-context', 'invoke.setup-isolate'];
-    static printMetrics = (shouldReportMetrics, metrics, logger) => {
-        if (shouldReportMetrics && metrics?.length) {
-            logger.debug(`Metrics: ${JSON.stringify(metrics.filter((m) => !LocalInvocationService.INTERNAL_METRICS.includes(m.name)), null, 2)}`);
-        }
-    };
 }
 exports.LocalInvocationService = LocalInvocationService;
+LocalInvocationService.INTERNAL_METRICS = ['execute.setup-request-context', 'invoke.setup-isolate'];
+LocalInvocationService.printMetrics = (shouldReportMetrics, metrics, logger) => {
+    if (shouldReportMetrics && (metrics === null || metrics === void 0 ? void 0 : metrics.length)) {
+        logger.debug(`Metrics: ${JSON.stringify(metrics.filter((m) => !LocalInvocationService.INTERNAL_METRICS.includes(m.name)), null, 2)}`);
+    }
+};

package/out/services/register-tunnel-service.js

@@ -3,13 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegisterTunnelServiceImpl = void 0;
 const ONE_DAY = 1000 * 60 * 60 * 24;
 class RegisterTunnelServiceImpl {
-    tunnelClient;
     constructor(tunnelClient) {
         this.tunnelClient = tunnelClient;
         this.keepAliveActive = true;
     }
-    keepAliveHandler;
-    keepAliveActive;
     async registerTunnels(appId, environmentKey, tunnelDefinitions) {
         if (!this.keepAliveActive) {
             return;

package/out/util/sandboxes-container.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxesContainer = void 0;
 class SandboxesContainer {
-    sandboxes = {};
-    static instance = new SandboxesContainer();
+    constructor() {
+        this.sandboxes = {};
+    }
     static get() {
         return this.instance.sandboxes;
     }
@@ -12,3 +13,4 @@ class SandboxesContainer {
     }
 }
 exports.SandboxesContainer = SandboxesContainer;
+SandboxesContainer.instance = new SandboxesContainer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/tunnel",
-  "version": "5.0.2-next.1",
+  "version": "5.0.2-next.3",
   "description": "Tunnel functionality for Forge CLI",
   "author": "Atlassian",
   "license": "UNLICENSED",
@@ -11,8 +11,8 @@
     "compile": "tsc -b -v"
   },
   "dependencies": {
-    "@forge/bundler": "4.15.11-next.0",
-    "@forge/cli-shared": "4.0.1-next.0",
+    "@forge/bundler": "4.15.11-next.2",
+    "@forge/cli-shared": "4.0.1-next.2",
     "@forge/csp": "3.2.1",
     "@forge/runtime": "5.7.0-next.0",
     "express": "^4.18.3",
@@ -27,7 +27,7 @@
   },
   "devDependencies": {
     "@atlassian/xen-test-util": "^4.2.0",
-    "@forge/manifest": "7.2.0-next.0",
+    "@forge/manifest": "7.2.0-next.2",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.12",
     "@types/node": "14.18.63",