@forge/tunnel 5.2.1-next.6 → 5.2.1-next.7

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @forge/tunnel
 
+## 5.2.1-next.7
+
+### Patch Changes
+
+- Updated dependencies [670a419]
+  - @forge/cli-shared@5.0.0-next.6
+  - @forge/bundler@4.16.2-next.7
+
 ## 5.2.1-next.6
 
 ### Patch Changes

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

@@ -10,15 +10,16 @@ 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 });
@@ -52,13 +53,12 @@ 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: (_a = bundledCode.sourceMap) === null || _a === void 0 ? void 0 : _a[sourceMapPath]
+                bundleFileSourceMap: bundledCode.sourceMap?.[sourceMapPath]
             };
         });
         const manifestFilePath = (0, path_1.resolve)(directory, cli_shared_1.manifestFileName);
@@ -88,6 +88,9 @@ class LocalFunctionHost {
     async stopWatching() {
         runtime_1.StaticInvocationEventEmitter.removeAllListeners();
     }
+    onRuntimeLog = (event) => {
+        this.logger.info((0, util_1.formatRuntimeLog)(event));
+    };
     async initializeSandboxes(srcPath, tunnelOptions) {
         try {
             util_1.SandboxesContainer.stopSandboxes();

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiCompilerWatcher = void 0;
 const cli_shared_1 = require("@forge/cli-shared");
 class MultiCompilerWatcher {
+    servers;
     constructor(servers) {
         this.servers = servers;
     }
@@ -15,9 +16,18 @@ class MultiCompilerWatcher {
             output: {}
         };
         for (const result of results) {
-            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);
+            multiResult.output = {
+                ...multiResult.output,
+                ...result.output
+            };
+            multiResult.sourceMap = {
+                ...multiResult.sourceMap,
+                ...result.sourceMap
+            };
+            multiResult.metadata = {
+                ...multiResult.metadata,
+                ...result.metadata
+            };
         }
         return multiResult;
     }

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

@@ -7,55 +7,9 @@ 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 = cli_shared_1.defaultNoDebugTunnelOptions) => {
-            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
-                        }
-                    }, tunnelOptions);
-                    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) => {
@@ -88,5 +42,52 @@ class TunnelInteractor {
             process.on('SIGTERM', tunnelCleanupListener);
         });
     }
+    watchApp = async (startTunnelResult, tunnelOptions = cli_shared_1.defaultNoDebugTunnelOptions) => {
+        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
+                    }
+                }, tunnelOptions);
+                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,6 +8,16 @@ 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;
@@ -17,51 +27,58 @@ class StartTunnelCommand {
         this.inspector = inspector;
         this.logger = logger;
         this.configFile = configFile;
-        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()
-            ]);
+    }
+    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, appId, environmentKey }) => {
+        const { permissions = {}, remotes = [] } = await this.configFile.readConfig();
+        const serverInfo = await this.devServer.start(port, permissions, remotes);
+        const { id, token, url } = await this.tunnelClient.setupTunnel(appId, environmentKey);
+        const faasTunnelUrl = await this.tunnelFactory.establishTunnel({
+            port: serverInfo.port,
+            tunnelConfigPath,
+            id,
+            token,
+            tunnelUrl: url
+        });
+        return {
+            ...serverInfo,
+            tunnelUrl: faasTunnelUrl
         };
-        this.startFaaSTunnelServer = async ({ port, tunnelConfigPath, appId, environmentKey }) => {
-            const { permissions = {}, remotes = [] } = await this.configFile.readConfig();
-            const serverInfo = await this.devServer.start(port, permissions, remotes);
-            const { id, token, url } = await this.tunnelClient.setupTunnel(appId, environmentKey);
-            const faasTunnelUrl = await this.tunnelFactory.establishTunnel({
-                port: serverInfo.port,
-                tunnelConfigPath,
-                id,
-                token,
-                tunnelUrl: url
+    };
+    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 Object.assign(Object.assign({}, serverInfo), { tunnelUrl: faasTunnelUrl });
-        };
-        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();
-            }));
-        };
-    }
+            return this.tunnelServers[key].start();
+        }));
+    };
     async execute(options) {
         const { id: appId } = await this.getAppConfig();
         const { port, environmentKey } = options;
@@ -111,7 +128,7 @@ class StartTunnelCommand {
             try {
                 await this.stopServices(appId, environmentKey);
             }
-            catch (_a) { }
+            catch { }
             throw e;
         }
     }

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

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

package/out/sandbox/node-sandbox.js

@@ -9,6 +9,9 @@ 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`;
@@ -25,10 +28,9 @@ class NodeSandbox {
             this.handleOutput(message);
         });
         this.process.on('message', (message) => {
-            var _a;
             const requestId = message.requestId;
             const result = message.result;
-            (_a = this.callbacks.get(requestId)) === null || _a === void 0 ? void 0 : _a(result);
+            this.callbacks.get(requestId)?.(result);
         });
     }
     handleOutput(output) {

package/out/sandbox/sandbox-runner.js

@@ -3,8 +3,7 @@ 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);
-    (_a = process.send) === null || _a === void 0 ? void 0 : _a.call(process, { requestId, result });
+    process.send?.({ requestId, result });
 });

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

@@ -5,6 +5,12 @@ 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;
@@ -35,10 +41,8 @@ class CspReporterServer {
     }
     async stop() {
         return new Promise((resolve, reject) => {
-            var _a;
-            (_a = this.server) === null || _a === void 0 ? void 0 : _a.close((err) => (err ? reject(err) : resolve()));
+            this.server?.close((err) => (err ? reject(err) : resolve()));
         });
     }
 }
 exports.CspReporterServer = CspReporterServer;
-CspReporterServer.TTL_IN_SECONDS = 30;

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

@@ -14,15 +14,19 @@ 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) {
-            (_b = (_a = net_1.default).setDefaultAutoSelectFamily) === null || _b === void 0 ? void 0 : _b.call(_a, true);
+            net_1.default.setDefaultAutoSelectFamily?.(true);
             const { port: tunnelPort } = tunnel;
             this.proxy = (0, http_proxy_middleware_1.createProxyMiddleware)({
                 target: `http://${this.tunnelArgs.host}:${tunnelPort}`,
@@ -80,7 +84,7 @@ class CustomUITunnelServer extends resource_tunnel_server_1.ResourceTunnelServer
         return this.app;
     }
     handleProxyDestinationNotStarted(err, reqUrl, res, tunnelPort) {
-        if ((err === null || err === void 0 ? void 0 : err.code) !== ConnectionErrorCode.REFUSED || (reqUrl !== '/' && reqUrl !== 'index.html')) {
+        if (err?.code !== ConnectionErrorCode.REFUSED || (reqUrl !== '/' && reqUrl !== 'index.html')) {
             this.logger.error(err);
             return;
         }
@@ -91,9 +95,8 @@ 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 ((_a = this.proxy) === null || _a === void 0 ? void 0 : _a.upgrade) {
+        if (this.proxy?.upgrade) {
             return this.proxy.upgrade(req, socket, head);
         }
     }

package/out/servers/dev-server.js

@@ -18,44 +18,19 @@ 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);
@@ -120,5 +95,41 @@ 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,19 +8,26 @@ 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)(Object.assign(Object.assign({}, config), { infrastructureLogging: {
+        const compiler = (0, bundler_1.getCompiler)({
+            ...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,31 +5,12 @@ 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;
@@ -37,19 +18,43 @@ class ResourceTunnelServer {
         this.cspReporterServerPort = cspReporterServerPort;
     }
     static transformPermissionsWithRemotes(permissions, remotes) {
-        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;
+        const client = permissions.external?.fetch?.client
+            ?.map((item) => {
             if (typeof item === 'string')
                 return item;
-            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 }) }) });
+            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 } } };
     }
     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

@@ -38,6 +38,9 @@ class CloudflareError extends cli_shared_1.BaseError {
 }
 exports.CloudflareError = CloudflareError;
 class TunnelServiceFacade {
+    featureFlagService;
+    logger;
+    instance;
     constructor(featureFlagService, logger) {
         this.featureFlagService = featureFlagService;
         this.logger = logger;
@@ -59,6 +62,8 @@ class TunnelServiceFacade {
 }
 exports.TunnelServiceFacade = TunnelServiceFacade;
 class CloudflareCreateTunnelService {
+    logger;
+    stopFunction;
     constructor(logger) {
         this.logger = logger;
     }
@@ -83,13 +88,15 @@ class CloudflareCreateTunnelService {
             try {
                 this.stopFunction('SIGKILL');
             }
-            catch (_a) { }
+            catch { }
             this.stopFunction = undefined;
         }
     }
 }
 exports.CloudflareCreateTunnelService = CloudflareCreateTunnelService;
 class NgrokCreateTunnelService {
+    logger;
+    endpoint;
     constructor(logger) {
         this.logger = logger;
     }
@@ -99,7 +106,7 @@ class NgrokCreateTunnelService {
         try {
             const options = {
                 addr: port,
-                configPath: tunnelConfigPath !== null && tunnelConfigPath !== void 0 ? tunnelConfigPath : defaultConfigPath,
+                configPath: tunnelConfigPath ?? defaultConfigPath,
                 onStatusChange: (status) => {
                     this.logger.debug(cli_shared_1.Text.tunnel.tunnelStatusChange(status));
                 },
@@ -110,7 +117,7 @@ class NgrokCreateTunnelService {
                         try {
                             ngrokErrorMessage = JSON.parse(ngrokErrorMessage);
                         }
-                        catch (_a) { }
+                        catch { }
                     }
                     this.logger.debug(data);
                 }
@@ -129,7 +136,7 @@ class NgrokCreateTunnelService {
                 await ngrok.disconnect();
                 await ngrok.kill();
             }
-            catch (_a) { }
+            catch { }
             this.endpoint = undefined;
         }
     }

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

@@ -8,13 +8,15 @@ 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];
@@ -38,9 +40,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 = (_a = request._meta.timeout) !== null && _a !== void 0 ? _a : DEFAULT_INVOCATION_TIMEOUT;
+        const timeout = request._meta.timeout ?? DEFAULT_INVOCATION_TIMEOUT;
         const xenInvocationRequest = (0, runtime_1.xenInvocationRequestFactory)({
-            request: Object.assign(Object.assign({}, request), { variables }),
+            request: { ...request, variables },
             ctx: { requestId, traceId: requestId, timeout }
         });
         const invocationLimits = (0, runtime_1.perInvocationLimitsTrackerFactory)(xenInvocationRequest);
@@ -58,11 +60,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,11 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegisterTunnelServiceImpl = void 0;
 const ONE_DAY = 1000 * 60 * 60 * 24;
 class RegisterTunnelServiceImpl {
+    tunnelClient;
+    featureFlagService;
     constructor(tunnelClient, featureFlagService) {
         this.tunnelClient = tunnelClient;
         this.featureFlagService = featureFlagService;
         this.keepAliveActive = true;
     }
+    keepAliveHandler;
+    keepAliveActive;
     async registerTunnels(appId, environmentKey, tunnelDefinitions) {
         if (!this.keepAliveActive) {
             return;

package/out/util/sandboxes-container.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/tunnel",
-  "version": "5.2.1-next.6",
+  "version": "5.2.1-next.7",
   "description": "Tunnel functionality for Forge CLI",
   "author": "Atlassian",
   "license": "UNLICENSED",
@@ -11,8 +11,8 @@
     "compile": "tsc -b -v"
   },
   "dependencies": {
-    "@forge/bundler": "4.16.2-next.6",
-    "@forge/cli-shared": "5.0.0-next.5",
+    "@forge/bundler": "4.16.2-next.7",
+    "@forge/cli-shared": "5.0.0-next.6",
     "@forge/csp": "3.2.1",
     "@forge/runtime": "5.8.0",
     "cloudflared": "^0.5.1",
@@ -28,7 +28,7 @@
   },
   "devDependencies": {
     "@atlassian/xen-test-util": "^4.2.0",
-    "@forge/manifest": "7.3.0-next.4",
+    "@forge/manifest": "7.3.0-next.5",
     "@types/express": "^4.17.21",
     "@types/jest": "^29.5.12",
     "@types/node": "14.18.63",