@forge/cli 0.0.0-experimental-deeb8f6 → 0.0.0-experimental-c8e9749

package/out/service/resources-uploader-service.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourcesUploaderService = void 0;
+const tslib_1 = require("tslib");
+const cli_shared_1 = require("@forge/cli-shared");
+const form_data_1 = tslib_1.__importDefault(require("form-data"));
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+class ResourceUploadError extends cli_shared_1.BaseError {
+    constructor(userError) {
+        super('Failed to upload resource to S3');
+        this.userError = userError;
+    }
+    isUserError() {
+        return Boolean(this.userError);
+    }
+}
+class ResourcesUploaderService {
+    constructor(fileSystemReader) {
+        this.fileSystemReader = fileSystemReader;
+    }
+    async upload({ archive, preSignedUrl }) {
+        const content = this.fileSystemReader.readBinaryFile(archive);
+        const formData = new form_data_1.default();
+        formData.append('Content-Type', 'application/zip');
+        formData.append('acl', 'bucket-owner-full-control');
+        Object.entries(preSignedUrl.uploadFormData).forEach(([k, v]) => {
+            formData.append(k, v);
+        });
+        formData.append('file', content);
+        const response = await (0, node_fetch_1.default)(preSignedUrl.uploadUrl, {
+            method: 'POST',
+            body: formData
+        });
+        if (!response.ok) {
+            throw new ResourceUploadError(response.status >= 400 && response.status < 500);
+        }
+    }
+}
+exports.ResourcesUploaderService = ResourcesUploaderService;

package/out/service/tunnel-analytics-service.d.ts

@@ -0,0 +1,11 @@
+import { PersonalApiCredentialsValidated } from '@forge/cli-shared';
+import { AnalyticsClientReporter } from '../analytics-client/analytics-client';
+import { DownloadProgressCallbacks } from '../command-line/view/tunnel-view';
+export declare class TunnelAnalyticsService {
+    private readonly analyticsClientReporter;
+    constructor(analyticsClientReporter: AnalyticsClientReporter);
+    reportDockerVersion(creds: PersonalApiCredentialsValidated, dockerVersion: string | null): void;
+    reportTunnelClosed(creds: PersonalApiCredentialsValidated): void;
+    getImageDownloadReporters(creds: PersonalApiCredentialsValidated): DownloadProgressCallbacks;
+}
+//# sourceMappingURL=tunnel-analytics-service.d.ts.map

package/out/service/tunnel-analytics-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel-analytics-service.d.ts","sourceRoot":"","sources":["../../src/service/tunnel-analytics-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAE7E,qBAAa,sBAAsB;IACrB,OAAO,CAAC,QAAQ,CAAC,uBAAuB;gBAAvB,uBAAuB,EAAE,uBAAuB;IAEtE,mBAAmB,CAAC,KAAK,EAAE,+BAA+B,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAM/F,kBAAkB,CAAC,KAAK,EAAE,+BAA+B,GAAG,IAAI;IAIhE,yBAAyB,CAAC,KAAK,EAAE,+BAA+B,GAAG,yBAAyB;CAOpG"}

package/out/service/tunnel-analytics-service.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelAnalyticsService = void 0;
+class TunnelAnalyticsService {
+    constructor(analyticsClientReporter) {
+        this.analyticsClientReporter = analyticsClientReporter;
+    }
+    reportDockerVersion(creds, dockerVersion) {
+        this.analyticsClientReporter.reportSuccess('docker version check', creds, {
+            dockerVersion
+        });
+    }
+    reportTunnelClosed(creds) {
+        this.analyticsClientReporter.reportSuccess('close tunnel', creds, {});
+    }
+    getImageDownloadReporters(creds) {
+        return {
+            onStart: () => this.analyticsClientReporter.reportSuccess('image download started', creds, {}),
+            onFailure: () => this.analyticsClientReporter.reportSuccess('image download failed', creds, {}),
+            onSuccess: () => this.analyticsClientReporter.reportSuccess('image download finished', creds, {})
+        };
+    }
+}
+exports.TunnelAnalyticsService = TunnelAnalyticsService;

package/out/service/tunnel-service.d.ts

@@ -0,0 +1,41 @@
+import { HiddenError, PersonalApiCredentials, PersonalApiCredentialsValidated } from '@forge/cli-shared';
+import { spawn } from 'cross-spawn';
+import { DockerService } from './docker-service';
+import { ConfigFilePortFindingService } from './port-finding-service';
+import { TunnelAnalyticsService } from './tunnel-analytics-service';
+export interface TunnelOptions {
+    debug?: boolean;
+}
+export declare const CONTAINER_NAME = "forge-tunnel-docker";
+export declare const IMAGE_NAME: string;
+export declare class HiddenDockerTunnelError extends HiddenError {
+}
+export declare abstract class TunnelService {
+    protected readonly configFilePortFindingService: ConfigFilePortFindingService;
+    constructor(configFilePortFindingService: ConfigFilePortFindingService);
+    abstract run(tunnelOptions: TunnelOptions, creds: PersonalApiCredentialsValidated, debugEnabled: boolean, onError?: (err: Error) => Promise<void>): Promise<void>;
+    protected getDockerOptions(tunnelOptions: TunnelOptions, debugEnabled: boolean, { email, token }: PersonalApiCredentials): Promise<string[]>;
+    protected getPortOptions(port: number, resourcePorts: Record<string, number>, cspReporterPort: number | undefined): string[];
+    protected getResourcePortEnvVarOption(resourcePorts: Record<string, number>): string[];
+    protected getUserEnvironmentVariablesOptions(): string[];
+    protected addEnvVarsForLocalTunnel(env: {
+        [key: string]: string;
+    }): Record<string, string>;
+    protected transformDockerOptionsToEnvVars(options: string[]): {
+        [key: string]: string;
+    };
+    protected getInteractiveOptions(): string[];
+    protected getVolumeOptions(): string[];
+}
+export declare class LocalTunnelService extends TunnelService {
+    run(tunnelOptions: TunnelOptions, creds: PersonalApiCredentials, debugEnabled: boolean, onError: (err: Error) => Promise<void>): Promise<void>;
+}
+export declare class DockerTunnelService extends TunnelService {
+    private readonly dockerService;
+    private readonly analyticsService;
+    constructor(configFilePortFindingService: ConfigFilePortFindingService, dockerService: DockerService, analyticsService: TunnelAnalyticsService);
+    run(tunnelOptions: TunnelOptions, creds: PersonalApiCredentialsValidated, debugEnabled: boolean): Promise<void>;
+    bootstrapDocker(): Promise<ReturnType<typeof spawn>>;
+    private validateDockerVersion;
+}
+//# sourceMappingURL=tunnel-service.d.ts.map

package/out/service/tunnel-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel-service.d.ts","sourceRoot":"","sources":["../../src/service/tunnel-service.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,WAAW,EACX,sBAAsB,EACtB,+BAA+B,EAChC,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAOpC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAKD,eAAO,MAAM,cAAc,wBAAwB,CAAC;AAcpD,eAAO,MAAM,UAAU,QAEuB,CAAC;AAE/C,qBAAa,uBAAwB,SAAQ,WAAW;CAAG;AAE3D,8BAAsB,aAAa;IACrB,SAAS,CAAC,QAAQ,CAAC,4BAA4B,EAAE,4BAA4B;gBAA1D,4BAA4B,EAAE,4BAA4B;aAEzE,GAAG,CACjB,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,+BAA+B,EACtC,YAAY,EAAE,OAAO,EACrB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,GACtC,OAAO,CAAC,IAAI,CAAC;cAEA,gBAAgB,CAC9B,aAAa,EAAE,aAAa,EAC5B,YAAY,EAAE,OAAO,EACrB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,sBAAsB,GACvC,OAAO,CAAC,MAAM,EAAE,CAAC;IA+BpB,SAAS,CAAC,cAAc,CACtB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACrC,eAAe,EAAE,MAAM,GAAG,SAAS,GAClC,MAAM,EAAE;IAwBX,SAAS,CAAC,2BAA2B,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE;IAItF,SAAS,CAAC,kCAAkC,IAAI,MAAM,EAAE;IAUxD,SAAS,CAAC,wBAAwB,CAAC,GAAG,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAQ1F,SAAS,CAAC,+BAA+B,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE;IAYvF,SAAS,CAAC,qBAAqB,IAAI,MAAM,EAAE;IAQ3C,SAAS,CAAC,gBAAgB,IAAI,MAAM,EAAE;CAgBvC;AAED,qBAAa,kBAAmB,SAAQ,aAAa;IACtC,GAAG,CACd,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,sBAAsB,EAC7B,YAAY,EAAE,OAAO,EACrB,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,OAAO,CAAC,IAAI,CAAC,GACrC,OAAO,CAAC,IAAI,CAAC;CA0BjB;AAED,qBAAa,mBAAoB,SAAQ,aAAa;IAGlD,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBAFjC,4BAA4B,EAAE,4BAA4B,EACzC,aAAa,EAAE,aAAa,EAC5B,gBAAgB,EAAE,sBAAsB;IAK9C,GAAG,CACd,aAAa,EAAE,aAAa,EAC5B,KAAK,EAAE,+BAA+B,EACtC,YAAY,EAAE,OAAO,GACpB,OAAO,CAAC,IAAI,CAAC;IA2BH,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC;YAKnD,qBAAqB;CASpC"}

package/out/service/tunnel-service.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerTunnelService = exports.LocalTunnelService = exports.TunnelService = exports.HiddenDockerTunnelError = exports.IMAGE_NAME = exports.CONTAINER_NAME = void 0;
+const tslib_1 = require("tslib");
+const cli_shared_1 = require("@forge/cli-shared");
+const cross_spawn_1 = require("cross-spawn");
+const os_1 = tslib_1.__importDefault(require("os"));
+const path_1 = require("path");
+const portfinder_1 = require("portfinder");
+const semver_1 = require("semver");
+const version_info_1 = require("../command-line/version-info");
+const DISABLE_TTY = process.env.DISABLE_TTY === 'true';
+const CUR_WORK_APP_DIR = process.env.CUR_WORK_APP_DIR;
+exports.CONTAINER_NAME = 'forge-tunnel-docker';
+const cliDetails = (0, version_info_1.getCLIDetails)();
+let versionTags;
+if ((cliDetails === null || cliDetails === void 0 ? void 0 : cliDetails.version) !== undefined) {
+    if (process.env.FORGE_IN_LOCAL_E2E === 'true') {
+        versionTags = ['e2e'];
+    }
+    else {
+        versionTags = (0, semver_1.prerelease)(cliDetails.version) || ['latest'];
+    }
+}
+else {
+    versionTags = ['latest'];
+}
+exports.IMAGE_NAME = process.env.FORGE_DEV_DOCKER_TUNNEL
+    ? 'local/forge-tunnel:test'
+    : `atlassian/forge-tunnel:${versionTags[0]}`;
+class HiddenDockerTunnelError extends cli_shared_1.HiddenError {
+}
+exports.HiddenDockerTunnelError = HiddenDockerTunnelError;
+class TunnelService {
+    constructor(configFilePortFindingService) {
+        this.configFilePortFindingService = configFilePortFindingService;
+    }
+    async getDockerOptions(tunnelOptions, debugEnabled, { email, token }) {
+        try {
+            const graphqlGateway = (0, cli_shared_1.getGraphqlGateway)();
+            return [
+                '--rm',
+                `--name`,
+                exports.CONTAINER_NAME,
+                `--env`,
+                `APP_FOLDER=/app`,
+                `--env`,
+                `FORGE_EMAIL=${email}`,
+                `--env`,
+                `FORGE_API_TOKEN=${token}`,
+                `--env`,
+                `ENVIRONMENT_KEY=default`,
+                `--env`,
+                `TUNNEL_INSPECTOR_ENABLED=${!!tunnelOptions.debug}`,
+                `--env`,
+                `FORGE_GRAPHQL_GATEWAY=${graphqlGateway}`,
+                `--env`,
+                `VERBOSE_MODE=${debugEnabled}`,
+                `--env`,
+                `CLI_DETAILS=${JSON.stringify(cliDetails)}`,
+                `${exports.IMAGE_NAME}`
+            ];
+        }
+        catch (e) {
+            throw new HiddenDockerTunnelError("Couldn't populate docker options for tunneling");
+        }
+    }
+    getPortOptions(port, resourcePorts, cspReporterPort) {
+        const resourcePortOptions = (0, cli_shared_1.flatMap)(Object.values(resourcePorts), (resourcePort) => [
+            '-p',
+            `${resourcePort}:${resourcePort}`
+        ]);
+        const cspReporterPortOption = cspReporterPort
+            ? ['-p', `${cspReporterPort}:${cspReporterPort}`, '--env', `CSP_REPORTER_PORT=${cspReporterPort}`]
+            : [];
+        const addHostOption = os_1.default.platform() === 'linux' ? ['--add-host', 'host.docker.internal:host-gateway'] : [];
+        return [
+            `-p`,
+            `${port}:${port}`,
+            ...resourcePortOptions,
+            ...addHostOption,
+            ...cspReporterPortOption,
+            `--env`,
+            `TUNNEL_INSPECTOR_PORT=${port}`
+        ];
+    }
+    getResourcePortEnvVarOption(resourcePorts) {
+        return ['--env', `RESOURCE_PORT_MAP=${JSON.stringify(resourcePorts)}`];
+    }
+    getUserEnvironmentVariablesOptions() {
+        const options = [];
+        Object.keys(process.env)
+            .filter((variable) => variable.startsWith('FORGE_USER_VAR_'))
+            .forEach((name) => {
+            options.push('--env', `${name}=${process.env[name]}`);
+        });
+        return options;
+    }
+    addEnvVarsForLocalTunnel(env) {
+        return Object.assign(Object.assign({}, env), { PATH: process.env.PATH || '', FORCE_COLOR: '1' });
+    }
+    transformDockerOptionsToEnvVars(options) {
+        const envVarRegex = new RegExp('^(\\w+)=(.+)$', 'g');
+        const envVars = options.filter((opt) => envVarRegex.test(opt));
+        const envVarObj = {};
+        envVars.forEach((envVar) => {
+            envVarRegex.lastIndex = 0;
+            const [, key, val] = envVarRegex.exec(envVar);
+            envVarObj[key] = val;
+        });
+        return envVarObj;
+    }
+    getInteractiveOptions() {
+        if (DISABLE_TTY) {
+            return [`-i`];
+        }
+        return [`-it`];
+    }
+    getVolumeOptions() {
+        const options = [`-v=${CUR_WORK_APP_DIR || process.cwd()}:/app:cached`];
+        if (process.env.FORGE_DEV_DOCKER_TUNNEL) {
+            options.push(`-v=${(0, path_1.join)(__dirname, '../../../..')}:/monorepo:cached`);
+        }
+        if (process.env.FORGE_TUNNEL_MOUNT_DIRECTORIES) {
+            const mounts = process.env.FORGE_TUNNEL_MOUNT_DIRECTORIES.split(',');
+            mounts.forEach((mount) => {
+                options.push(`-v=${mount}:cached`);
+            });
+        }
+        return options;
+    }
+}
+exports.TunnelService = TunnelService;
+class LocalTunnelService extends TunnelService {
+    async run(tunnelOptions, creds, debugEnabled, onError) {
+        const dockerOptions = await this.getDockerOptions(tunnelOptions, debugEnabled, creds);
+        const port = await (0, portfinder_1.getPortPromise)();
+        const resourcePorts = await this.configFilePortFindingService.findPorts();
+        const cspReporterPort = await this.configFilePortFindingService.findPortAfter(Object.values(resourcePorts));
+        const portOptions = this.getPortOptions(port, resourcePorts, cspReporterPort);
+        const envVariablesOptions = this.getUserEnvironmentVariablesOptions();
+        const resourcePortEnvVarOption = this.getResourcePortEnvVarOption(resourcePorts);
+        const env = this.addEnvVarsForLocalTunnel(this.transformDockerOptionsToEnvVars([
+            ...dockerOptions,
+            ...portOptions,
+            ...envVariablesOptions,
+            ...resourcePortEnvVarOption
+        ]));
+        (0, cross_spawn_1.spawn)('forge-tunnel', [], {
+            stdio: 'inherit',
+            env: Object.assign(Object.assign({}, env), { FORGE_DEV_TUNNEL: 'true' })
+        }).on('error', onError);
+    }
+}
+exports.LocalTunnelService = LocalTunnelService;
+class DockerTunnelService extends TunnelService {
+    constructor(configFilePortFindingService, dockerService, analyticsService) {
+        super(configFilePortFindingService);
+        this.dockerService = dockerService;
+        this.analyticsService = analyticsService;
+    }
+    async run(tunnelOptions, creds, debugEnabled) {
+        await this.validateDockerVersion(creds, debugEnabled);
+        const dockerOptions = await this.getDockerOptions(tunnelOptions, debugEnabled, creds);
+        const port = await (0, portfinder_1.getPortPromise)();
+        const resourcePorts = await this.configFilePortFindingService.findPorts(port);
+        const cspReporterPort = await this.configFilePortFindingService.findPortAfter(Object.values(resourcePorts));
+        const portOptions = this.getPortOptions(port, resourcePorts, cspReporterPort);
+        const interactiveOptions = this.getInteractiveOptions();
+        const volumeOptions = this.getVolumeOptions();
+        const envVariablesOptions = this.getUserEnvironmentVariablesOptions();
+        const resourcePortEnvVarOption = this.getResourcePortEnvVarOption(resourcePorts);
+        const docker = this.dockerService.runContainer([
+            ...interactiveOptions,
+            ...volumeOptions,
+            ...portOptions,
+            ...envVariablesOptions,
+            ...resourcePortEnvVarOption,
+            ...dockerOptions
+        ]);
+        docker.on('exit', () => this.analyticsService.reportTunnelClosed(creds));
+        this.dockerService.startCleanupWorker([docker.pid], exports.CONTAINER_NAME);
+    }
+    async bootstrapDocker() {
+        await this.dockerService.removeContainer(exports.CONTAINER_NAME);
+        return this.dockerService.downloadImage(exports.IMAGE_NAME);
+    }
+    async validateDockerVersion(creds, debugEnabled) {
+        const { major, minor, full } = await this.dockerService.getDockerVersion(debugEnabled);
+        this.analyticsService.reportDockerVersion(creds, full);
+        if (major < 17 || (major === 17 && minor < 3)) {
+            throw new HiddenDockerTunnelError();
+        }
+    }
+}
+exports.DockerTunnelService = DockerTunnelService;

package/out/storage/local-file-storage.d.ts

@@ -0,0 +1,17 @@
+import { AnalyticsMessage } from '../analytics-client/analytics-message-handler';
+export interface Storage {
+    addAnalyticsEvent(message: AnalyticsMessage): void;
+    deleteAnalyticsEvent(file: string): Promise<void>;
+    getAnalytics(): string[];
+    getAnalyticsEvent(file: string): Promise<AnalyticsMessage | undefined>;
+}
+export declare class LocalFileStorage implements Storage {
+    private static STORAGE_PATHS;
+    private static FOLDER;
+    constructor();
+    addAnalyticsEvent(message: AnalyticsMessage): void;
+    getAnalyticsEvent(file: string): Promise<AnalyticsMessage | undefined>;
+    getAnalytics(): string[];
+    deleteAnalyticsEvent(file: string): Promise<void>;
+}
+//# sourceMappingURL=local-file-storage.d.ts.map

package/out/storage/local-file-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-file-storage.d.ts","sourceRoot":"","sources":["../../src/storage/local-file-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AAMjF,MAAM,WAAW,OAAO;IACtB,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACnD,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,YAAY,IAAI,MAAM,EAAE,CAAC;IACzB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAAC;CACxE;AAGD,qBAAa,gBAAiB,YAAW,OAAO;IAC9C,OAAO,CAAC,MAAM,CAAC,aAAa,CAAyB;IACrD,OAAO,CAAC,MAAM,CAAC,MAAM,CAAuC;;IAQ5D,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAQ5C,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC;IAgB5E,YAAY,IAAI,MAAM,EAAE;IASlB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAOxD"}

package/out/storage/local-file-storage.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFileStorage = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs = tslib_1.__importStar(require("fs"));
+const env_paths_1 = tslib_1.__importDefault(require("env-paths"));
+const mkdirp_1 = tslib_1.__importDefault(require("mkdirp"));
+class LocalFileStorage {
+    constructor() {
+        if (!fs.existsSync(LocalFileStorage.FOLDER)) {
+            mkdirp_1.default.sync(LocalFileStorage.FOLDER);
+        }
+    }
+    addAnalyticsEvent(message) {
+        try {
+            fs.writeFileSync(path_1.default.join(LocalFileStorage.FOLDER, `${message.id}.json`), JSON.stringify(message));
+        }
+        catch (e) {
+        }
+    }
+    async getAnalyticsEvent(file) {
+        try {
+            const content = await fs.promises.readFile(path_1.default.join(LocalFileStorage.FOLDER, file), {
+                encoding: 'utf8'
+            });
+            const parsedContent = JSON.parse(content);
+            parsedContent.event.timestamp = new Date(parsedContent.event.timestamp);
+            return parsedContent;
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    getAnalytics() {
+        try {
+            return fs.readdirSync(LocalFileStorage.FOLDER).filter((f) => f.endsWith('.json'));
+        }
+        catch (e) {
+            return [];
+        }
+    }
+    async deleteAnalyticsEvent(file) {
+        try {
+            await fs.promises.unlink(path_1.default.join(LocalFileStorage.FOLDER, file));
+        }
+        catch (e) {
+        }
+    }
+}
+exports.LocalFileStorage = LocalFileStorage;
+LocalFileStorage.STORAGE_PATHS = (0, env_paths_1.default)('forge-cli');
+LocalFileStorage.FOLDER = LocalFileStorage.STORAGE_PATHS.data;

package/out/webtrigger/get-webtrigger-url.d.ts

@@ -0,0 +1,27 @@
+import { AppConfigProvider } from '@forge/cli-shared';
+import { AppEnvironmentClient } from '@forge/cli-shared';
+import { Installation } from '../service/installation-service';
+import { WebTriggerGraphQLClient } from './graphql-client';
+export interface Context {
+    contextId: string;
+    environmentARI: string;
+    extensionKey: string;
+}
+export interface WebTriggerUrlDetails {
+    appId: string;
+    contextId: string;
+    environmentId: string;
+    triggerKey: string;
+}
+export interface WebTriggerClient {
+    getInstallation(appId: string, installationId: string): Promise<Installation>;
+}
+export declare class GetWebTriggerURLCommand {
+    private readonly getAppConfig;
+    private readonly webTriggerClient;
+    private readonly appEnvironmentClient;
+    private readonly webTriggerGraphqlClient;
+    constructor(getAppConfig: AppConfigProvider, webTriggerClient: WebTriggerClient, appEnvironmentClient: AppEnvironmentClient, webTriggerGraphqlClient: WebTriggerGraphQLClient);
+    execute(installationId: string, functionKey: string): Promise<string>;
+}
+//# sourceMappingURL=get-webtrigger-url.d.ts.map

package/out/webtrigger/get-webtrigger-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-webtrigger-url.d.ts","sourceRoot":"","sources":["../../src/webtrigger/get-webtrigger-url.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,MAAM,WAAW,OAAO;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;CAC/E;AACD,qBAAa,uBAAuB;IAEhC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,uBAAuB;gBAHvB,YAAY,EAAE,iBAAiB,EAC/B,gBAAgB,EAAE,gBAAgB,EAClC,oBAAoB,EAAE,oBAAoB,EAC1C,uBAAuB,EAAE,uBAAuB;IAGtD,OAAO,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAgBnF"}

package/out/webtrigger/get-webtrigger-url.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetWebTriggerURLCommand = void 0;
+const cs_ari_1 = require("@forge/util/packages/cs-ari");
+class GetWebTriggerURLCommand {
+    constructor(getAppConfig, webTriggerClient, appEnvironmentClient, webTriggerGraphqlClient) {
+        this.getAppConfig = getAppConfig;
+        this.webTriggerClient = webTriggerClient;
+        this.appEnvironmentClient = appEnvironmentClient;
+        this.webTriggerGraphqlClient = webTriggerGraphqlClient;
+    }
+    async execute(installationId, functionKey) {
+        const { id: appId } = await this.getAppConfig();
+        const { environmentKey, context } = await this.webTriggerClient.getInstallation(appId, installationId);
+        const environmentId = await this.appEnvironmentClient.getAppEnvironmentId(appId, environmentKey);
+        const ari = (0, cs_ari_1.parse)(appId);
+        const appAri = (0, cs_ari_1.parseAppAri)(ari);
+        return await this.webTriggerGraphqlClient.createWebTriggerUrl({
+            appId: appAri.appId,
+            contextId: context,
+            environmentId: environmentId,
+            triggerKey: functionKey
+        });
+    }
+}
+exports.GetWebTriggerURLCommand = GetWebTriggerURLCommand;

package/out/webtrigger/graphql-client.d.ts

@@ -0,0 +1,14 @@
+import { GraphQLClient, GraphQlMutationError } from '@forge/cli-shared';
+import { WebTriggerUrlDetails } from './get-webtrigger-url';
+export declare class WebTriggerCreationError extends GraphQlMutationError {
+    constructor(message: string, requestId: string | undefined, code: string | undefined);
+}
+export declare class MissingWebTriggerUrlError extends GraphQlMutationError {
+    constructor(requestId: string | undefined);
+}
+export declare class WebTriggerGraphQLClient {
+    private readonly graphQLClient;
+    constructor(graphQLClient: GraphQLClient);
+    createWebTriggerUrl({ appId, contextId, environmentId, triggerKey }: WebTriggerUrlDetails): Promise<string>;
+}
+//# sourceMappingURL=graphql-client.d.ts.map

package/out/webtrigger/graphql-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-client.d.ts","sourceRoot":"","sources":["../../src/webtrigger/graphql-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAyC,MAAM,mBAAmB,CAAC;AAC/G,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,qBAAa,uBAAwB,SAAQ,oBAAoB;gBACnD,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS;CAGrF;AAED,qBAAa,yBAA0B,SAAQ,oBAAoB;gBACrD,SAAS,EAAE,MAAM,GAAG,SAAS;CAQ1C;AAED,qBAAa,uBAAuB;IACtB,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAAb,aAAa,EAAE,aAAa;IAE5C,mBAAmB,CAAC,EAC/B,KAAK,EACL,SAAS,EACT,aAAa,EACb,UAAU,EACX,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC;CAoC1C"}

package/out/webtrigger/graphql-client.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebTriggerGraphQLClient = exports.MissingWebTriggerUrlError = exports.WebTriggerCreationError = void 0;
+const cli_shared_1 = require("@forge/cli-shared");
+class WebTriggerCreationError extends cli_shared_1.GraphQlMutationError {
+    constructor(message, requestId, code) {
+        super(cli_shared_1.Text.webtrigger.error.creationError(message), { requestId, code });
+    }
+}
+exports.WebTriggerCreationError = WebTriggerCreationError;
+class MissingWebTriggerUrlError extends cli_shared_1.GraphQlMutationError {
+    constructor(requestId) {
+        super(cli_shared_1.Text.webtrigger.error.creationError(`Web Trigger URL not found after successful creation, requestId: ${requestId !== null && requestId !== void 0 ? requestId : 'N/A'}`), { requestId });
+    }
+}
+exports.MissingWebTriggerUrlError = MissingWebTriggerUrlError;
+class WebTriggerGraphQLClient {
+    constructor(graphQLClient) {
+        this.graphQLClient = graphQLClient;
+    }
+    async createWebTriggerUrl({ appId, contextId, environmentId, triggerKey }) {
+        const query = `
+        mutation forge_cli_createWebTriggerUrl($input: WebTriggerUrlInput!) {
+            createWebTriggerUrl(input: $input) {
+            statusCode
+            success
+            message
+            url
+            }
+        }
+        `;
+        const variables = {
+            input: {
+                appId,
+                contextId,
+                envId: environmentId,
+                triggerKey
+            }
+        };
+        const { response: { createWebTriggerUrl: { success, statusCode, message, url } }, requestId } = await this.graphQLClient.mutate(query, variables);
+        if (!success) {
+            throw new WebTriggerCreationError(message, requestId, statusCode.toString());
+        }
+        else {
+            if (url) {
+                return url;
+            }
+            throw new MissingWebTriggerUrlError(requestId);
+        }
+    }
+}
+exports.WebTriggerGraphQLClient = WebTriggerGraphQLClient;

package/out/workers/analytics-message-worker.d.ts

@@ -0,0 +1,12 @@
+import { AnalyticsMessage, MessageHandler } from '../analytics-client/analytics-message-handler';
+import { CachedConfigService } from '../service/cached-config-service';
+import { Storage } from '../storage/local-file-storage';
+import { Worker } from './worker';
+export declare class AnalyticsMessageWorker implements Worker {
+    private readonly storage;
+    private readonly messageHandler;
+    private readonly cachedConfigService;
+    constructor(storage: Storage, messageHandler: MessageHandler<AnalyticsMessage | undefined>, cachedConfigService: CachedConfigService);
+    doWork(): Promise<void>;
+}
+//# sourceMappingURL=analytics-message-worker.d.ts.map

package/out/workers/analytics-message-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics-message-worker.d.ts","sourceRoot":"","sources":["../../src/workers/analytics-message-worker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAKlC,qBAAa,sBAAuB,YAAW,MAAM;IAEjD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,mBAAmB;gBAFnB,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,cAAc,CAAC,gBAAgB,GAAG,SAAS,CAAC,EAC5D,mBAAmB,EAAE,mBAAmB;IAGrD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAoB9B"}

package/out/workers/analytics-message-worker.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsMessageWorker = void 0;
+class AnalyticsMessageWorker {
+    constructor(storage, messageHandler, cachedConfigService) {
+        this.storage = storage;
+        this.messageHandler = messageHandler;
+        this.cachedConfigService = cachedConfigService;
+    }
+    async doWork() {
+        const analyticsSetting = this.cachedConfigService.getAnalyticsPreferences();
+        if (analyticsSetting === undefined) {
+            return;
+        }
+        try {
+            const events = this.storage.getAnalytics();
+            await Promise.all(events.map(async (event) => {
+                const payload = await this.storage.getAnalyticsEvent(event);
+                if (analyticsSetting) {
+                    await this.messageHandler.handleMessage(payload);
+                }
+                await this.storage.deleteAnalyticsEvent(event);
+            }));
+        }
+        catch (e) {
+        }
+    }
+}
+exports.AnalyticsMessageWorker = AnalyticsMessageWorker;

package/out/workers/forge-cli-workers.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=forge-cli-workers.d.ts.map

package/out/workers/forge-cli-workers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forge-cli-workers.d.ts","sourceRoot":"","sources":["../../src/workers/forge-cli-workers.ts"],"names":[],"mappings":""}

package/out/workers/forge-cli-workers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const analytics_message_handler_1 = require("../analytics-client/analytics-message-handler");
+const local_file_storage_1 = require("../storage/local-file-storage");
+const analytics_message_worker_1 = require("./analytics-message-worker");
+const worker_1 = require("./worker");
+const version_check_worker_1 = require("./version-check-worker");
+const cached_config_service_1 = require("../service/cached-config-service");
+const cli_shared_1 = require("@forge/cli-shared");
+const unique_machine_id_1 = require("../command-line/unique-machine-id");
+const workerInfo = JSON.parse(process.argv[2]);
+const cachedConf = cli_shared_1.CachedConf.getCache(unique_machine_id_1.FORGE_CLI_PACKAGE);
+const cachedConfigService = new cached_config_service_1.CachedConfigService(cachedConf);
+const ALL_WORKERS = [
+    new analytics_message_worker_1.AnalyticsMessageWorker(new local_file_storage_1.LocalFileStorage(), new analytics_message_handler_1.AnalyticsMessageHandler(workerInfo ? workerInfo.environment : undefined), cachedConfigService),
+    new version_check_worker_1.VersionCheckWorker(workerInfo)
+];
+const TIMEOUT = 10 * 1000;
+(0, worker_1.handleWithTimeout)(() => Promise.all(ALL_WORKERS.map((worker) => worker.doWork())), TIMEOUT)
+    .finally(() => process.exit(0))
+    .catch((e) => process.exit(1));

package/out/workers/tunnel-clean-up-worker.d.ts

@@ -0,0 +1,8 @@
+export declare type TunnelCleanUpMessage = {
+    pids: number[];
+    containers: string[];
+};
+export declare class TunnelCleanUpWorker {
+    doWork(): void;
+}
+//# sourceMappingURL=tunnel-clean-up-worker.d.ts.map

package/out/workers/tunnel-clean-up-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel-clean-up-worker.d.ts","sourceRoot":"","sources":["../../src/workers/tunnel-clean-up-worker.ts"],"names":[],"mappings":"AAGA,oBAAY,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAEF,qBAAa,mBAAmB;IACvB,MAAM,IAAI,IAAI;CAwBtB"}