heroku 8.1.8 → 8.2.0-beta.0

package/lib/commands/webhooks/remove.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+const base_1 = require("../../lib/webhooks/base");
+class WebhooksRemove extends base_1.default {
+    async run() {
+        const { flags, args } = await this.parse(WebhooksRemove);
+        const { path, display } = this.webhookType(flags);
+        const action = new spinner_1.default();
+        action.start(`Removing webhook ${args.id} from ${display}`);
+        await this.webhooksClient.delete(`${path}/webhooks/${args.id}`);
+        action.stop();
+    }
+}
+exports.default = WebhooksRemove;
+WebhooksRemove.description = 'removes a webhook from an app';
+WebhooksRemove.examples = [
+    '$ heroku webhooks:remove 99999999-9999-9999-9999-999999999999',
+];
+WebhooksRemove.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+};
+WebhooksRemove.args = {
+    id: core_1.Args.string({ description: 'id of webhook to remove', required: true }),
+};

package/lib/commands/webhooks/update.d.ts

@@ -0,0 +1,19 @@
+import BaseCommand from '../../lib/webhooks/base';
+export default class WebhooksUpdate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        remote: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        pipeline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        include: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        level: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        secret: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        authorization: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        url: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static args: {
+        id: import("@oclif/core/lib/interfaces/parser").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/webhooks/update.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const core_1 = require("@oclif/core");
+const spinner_1 = require("@oclif/core/lib/cli-ux/action/spinner");
+const base_1 = require("../../lib/webhooks/base");
+class WebhooksUpdate extends base_1.default {
+    async run() {
+        const { flags, args } = await this.parse(WebhooksUpdate);
+        const { path, display } = this.webhookType(flags);
+        const action = new spinner_1.default();
+        action.start(`Updating webhook ${args.id} for ${display}`);
+        await this.webhooksClient.patch(`${path}/webhooks/${args.id}`, {
+            body: {
+                include: flags.include && flags.include.split(',').map(s => s.trim()),
+                level: flags.level,
+                secret: flags.secret,
+                url: flags.url,
+            },
+        });
+        action.stop();
+    }
+}
+exports.default = WebhooksUpdate;
+WebhooksUpdate.description = 'updates a webhook in an app';
+WebhooksUpdate.examples = [
+    '$ heroku webhooks:update 99999999-9999-9999-9999-999999999999 -i dyno -l notify -s 09928c40bf1b191b645174a19f7053d16a180da37332e719ef0998f4c0a2 -u https://example.com/hooks',
+];
+WebhooksUpdate.flags = {
+    app: command_1.flags.app(),
+    remote: command_1.flags.remote(),
+    pipeline: command_1.flags.pipeline({ char: 'p', description: 'pipeline on which to list', hidden: true }),
+    include: command_1.flags.string({ char: 'i', description: 'comma delimited event types your server will receive ', required: true }),
+    level: command_1.flags.string({ char: 'l', description: 'notify does not retry, sync will retry until successful or timeout', required: true }),
+    secret: command_1.flags.string({ char: 's', description: 'value to sign delivery with in Heroku-Webhook-Hmac-SHA256 header' }),
+    authorization: command_1.flags.string({ char: 't', description: 'authoriation header to send with webhooks' }),
+    url: command_1.flags.string({ char: 'u', description: 'URL for receiver', required: true }),
+};
+WebhooksUpdate.args = {
+    id: core_1.Args.string({ required: true }),
+};

package/lib/file.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.realpathSync = exports.outputJSON = exports.readJSON = exports.removeEmptyDirs = exports.ls = exports.remove = exports.rename = exports.stat = exports.exists = void 0;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const deps_1 = tslib_1.__importDefault(require("./deps"));
+const path = require("path");
+const deps_1 = require("./deps");
 const debug = require('debug')('heroku-cli:file');
 function exists(f) {
     return deps_1.default.fs.pathExists(f);

package/lib/global_telemetry.d.ts

@@ -0,0 +1,53 @@
+import 'dotenv/config';
+interface Telemetry {
+    command: string;
+    os: string;
+    version: string;
+    exitCode: number;
+    exitState: string[];
+    cliRunDuration: number;
+    commandRunDuration: number;
+    lifecycleHookCompletion: {
+        init: boolean;
+        prerun: boolean;
+        postrun: boolean;
+        command_not_found: boolean;
+    };
+}
+export interface TelemetryGlobal extends NodeJS.Global {
+    cliTelemetry?: Telemetry;
+}
+export declare function setupTelemetry(config: any, opts: any): {
+    command: any;
+    os: any;
+    version: any;
+    exitCode: number;
+    exitState: string[];
+    cliRunDuration: number;
+    commandRunDuration: number;
+    lifecycleHookCompletion: {
+        init: boolean;
+        prerun: boolean;
+        postrun: boolean;
+        command_not_found: boolean;
+    };
+};
+export declare function computeDuration(cmdStartTime: any): number;
+export declare function reportCmdNotFound(config: any): {
+    command: string;
+    os: any;
+    version: any;
+    exitCode: number;
+    exitState: string[];
+    cliRunDuration: number;
+    commandRunDuration: number;
+    lifecycleHookCompletion: {
+        init: boolean;
+        prerun: boolean;
+        postrun: boolean;
+        command_not_found: boolean;
+    };
+};
+export declare function sendTelemetry(currentTelemetry: any): Promise<void>;
+export declare function sendToRollbar(data: any): Promise<void>;
+export {};

package/lib/global_telemetry.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendToRollbar = exports.sendTelemetry = exports.reportCmdNotFound = exports.computeDuration = exports.setupTelemetry = void 0;
+const Rollbar = require("rollbar");
+require("dotenv/config");
+const isDev = process.env.IS_DEV_ENVIRONMENT === 'true';
+const debug = require('debug')('global_telemetry');
+const rollbar = new Rollbar({
+    accessToken: '41f8730238814af69c248e2f7ca59ff2',
+    captureUncaught: true,
+    captureUnhandledRejections: true,
+    environment: isDev ? 'development' : 'production',
+});
+function setupTelemetry(config, opts) {
+    const now = new Date();
+    const cmdStartTime = now.getTime();
+    return {
+        command: opts.Command.id,
+        os: config.platform,
+        version: config.version,
+        exitCode: 0,
+        exitState: [''],
+        cliRunDuration: 0,
+        commandRunDuration: cmdStartTime,
+        lifecycleHookCompletion: {
+            init: true,
+            prerun: true,
+            postrun: false,
+            command_not_found: false,
+        },
+    };
+}
+exports.setupTelemetry = setupTelemetry;
+function computeDuration(cmdStartTime) {
+    // calculate time duration from start time till now
+    const now = new Date();
+    const cmdFinishTime = now.getTime();
+    return cmdFinishTime - cmdStartTime;
+}
+exports.computeDuration = computeDuration;
+function reportCmdNotFound(config) {
+    return {
+        command: '',
+        os: config.platform,
+        version: config.version,
+        exitCode: 0,
+        exitState: ['command_not_found'],
+        cliRunDuration: 0,
+        commandRunDuration: 0,
+        lifecycleHookCompletion: {
+            init: true,
+            prerun: false,
+            postrun: false,
+            command_not_found: true,
+        },
+    };
+}
+exports.reportCmdNotFound = reportCmdNotFound;
+async function sendTelemetry(currentTelemetry) {
+    // send telemetry to honeycomb and rollbar
+    let telemetry = currentTelemetry;
+    if (telemetry instanceof Error) {
+        telemetry = { error_message: telemetry.message, error_stack: telemetry.stack };
+        telemetry.cliRunDuration = currentTelemetry.cliRunDuration;
+        await sendToRollbar(telemetry);
+    }
+    // add sendToHoneycomb function here
+}
+exports.sendTelemetry = sendTelemetry;
+async function sendToRollbar(data) {
+    try {
+        // send data to rollbar
+        rollbar.error('Failed to complete execution', data, () => {
+            process.exit(1);
+        });
+    }
+    catch (_a) {
+        debug('Could not send error report');
+        process.exit(1);
+    }
+}
+exports.sendToRollbar = sendToRollbar;

package/lib/hooks/command_not_found/performance_analytics.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const performance_analytics: Hook<'command_not_found'>;
+export default performance_analytics;

package/lib/hooks/command_not_found/performance_analytics.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry = require("../../global_telemetry");
+const performance_analytics = async function () {
+    global.cliTelemetry = telemetry.reportCmdNotFound(this.config);
+};
+exports.default = performance_analytics;

package/lib/hooks/init/terms-of-service.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkTos = void 0;
-const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const path = tslib_1.__importStar(require("path"));
-const fs = tslib_1.__importStar(require("fs-extra"));
+const path = require("path");
+const fs = require("fs-extra");
 function checkTos(options) {
     const tosPath = path.join(options.config.cacheDir, 'terms-of-service');
     const viewedBanner = fs.pathExistsSync(tosPath);
     const message = 'Our terms of service have changed: https://dashboard.heroku.com/terms-of-service';
     if (!viewedBanner) {
-        core_1.CliUx.ux.warn(message);
+        core_1.ux.warn(message);
         fs.createFile(tosPath);
     }
 }

package/lib/hooks/init/version.d.ts

@@ -1,2 +1,3 @@
 import { Hook } from '@oclif/core';
-export declare const version: Hook.Init;
+declare const version: Hook.Init;
+export default version;

package/lib/hooks/init/version.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.version = void 0;
 const allowlist = [
     'HEROKU_API_KEY',
     'HEROKU_APP',
@@ -21,4 +20,4 @@ const version = async function () {
         }
     }
 };
-exports.version = version;
+exports.default = version;

package/lib/hooks/postrun/performance_analytics.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const performance_analytics: Hook<'postrun'>;
+export default performance_analytics;

package/lib/hooks/postrun/performance_analytics.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const telemetry = require("../../global_telemetry");
+const performance_analytics = async function () {
+    if (global.cliTelemetry) {
+        const cmdStartTime = global.cliTelemetry.commandRunDuration;
+        global.cliTelemetry.commandRunDuration = telemetry.computeDuration(cmdStartTime);
+        global.cliTelemetry.lifecycleHookCompletion.postrun = true;
+    }
+};
+exports.default = performance_analytics;

package/lib/hooks/prerun/analytics.d.ts

@@ -1,2 +1,3 @@
 import { Hook } from '@oclif/core';
-export declare const analytics: Hook<'prerun'>;
+declare const analytics: Hook<'prerun'>;
+export default analytics;

package/lib/hooks/prerun/analytics.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analytics = void 0;
-const tslib_1 = require("tslib");
-const analytics_1 = tslib_1.__importDefault(require("../../analytics"));
+const analytics_1 = require("../../analytics");
+const telemetry = require("../../global_telemetry");
 const analytics = async function (options) {
+    global.cliTelemetry = telemetry.setupTelemetry(this.config, options);
     const analytics = new analytics_1.default(this.config);
     await analytics.record(options);
 };
-exports.analytics = analytics;
+exports.default = analytics;

package/lib/hooks/recache.d.ts

@@ -0,0 +1,3 @@
+import { Interfaces } from '@oclif/core';
+declare const completions: Interfaces.Hook<'app' | 'addon' | 'config' | 'login' | 'logout'>;
+export default completions;

package/lib/hooks/recache.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@heroku-cli/command");
+const completions_1 = require("@heroku-cli/command/lib/completions");
+const core_1 = require("@oclif/core");
+const fs = require("fs-extra");
+const path = require("path");
+const cache_1 = require("../lib/autocomplete/cache");
+const create_1 = require("../commands/autocomplete/create");
+const completions = async function ({ type, app }) {
+    // autocomplete is now in core, skip windows
+    if (this.config.windows)
+        return;
+    const logInOut = type === 'login' || type === 'logout';
+    const completionsDir = path.join(this.config.cacheDir, 'autocomplete', 'completions');
+    const rm = () => fs.emptyDir(completionsDir);
+    const rmKey = (cacheKey) => fs.remove(path.join(completionsDir, cacheKey));
+    if (type === 'app')
+        return rmKey('app');
+    if (type === 'addon' && app)
+        return rmKey(`${app}_addons`);
+    if (type === 'config' && app)
+        return rmKey(`${app}_config_vars`);
+    if (logInOut)
+        return rm();
+    const update = async (completion, cacheKey) => {
+        const cachePath = path.join(completionsDir, cacheKey);
+        const options = await completion.options({ config: this.config });
+        await (0, cache_1.updateCache)(cachePath, options);
+    };
+    // if user is not logged in, exit
+    try {
+        const heroku = new command_1.APIClient(this.config);
+        if (!heroku.auth)
+            return;
+        await heroku.get('/account', { retryAuth: false });
+    }
+    catch (error) {
+        this.debug(error.message);
+        return;
+    }
+    core_1.ux.action.start('Updating completions');
+    await rm();
+    await create_1.default.run([], this.config);
+    try {
+        await update(completions_1.AppCompletion, 'app');
+        await update(completions_1.PipelineCompletion, 'pipeline');
+        await update(completions_1.SpaceCompletion, 'space');
+        await update(completions_1.TeamCompletion, 'team');
+    }
+    catch (error) {
+        this.debug(error.message);
+    }
+    core_1.ux.action.stop();
+};
+exports.default = completions;

package/lib/hooks/update/brew.d.ts

@@ -1,2 +1,3 @@
 import { Hook } from '@oclif/core';
-export declare const brewHook: Hook<'update'>;
+declare const brewHook: Hook<'update'>;
+export default brewHook;

package/lib/hooks/update/brew.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.brewHook = void 0;
-const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
-const path = tslib_1.__importStar(require("path"));
-const fs = tslib_1.__importStar(require("../../file"));
+const path = require("path");
+const fs = require("../../file");
 const debug = require('debug')('heroku:brewhook');
 function brew(args, opts = {}) {
     debug('brew %o', args);
@@ -45,4 +43,4 @@ const brewHook = async function () {
     brew(['uninstall', 'heroku']);
     brew(['install', 'heroku/brew/heroku']);
 };
-exports.brewHook = brewHook;
+exports.default = brewHook;

package/lib/hooks/update/completions.d.ts

@@ -1,2 +1,3 @@
 import { Hook } from '@oclif/core';
-export declare const brewHook: Hook<'update'>;
+declare const doRecache: Hook<'update'>;
+export default doRecache;

package/lib/hooks/update/completions.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.brewHook = void 0;
-const brewHook = async function () {
+const doRecache = async function () {
     // autocomplete is now in core, skip windows
     if (this.config.windows)
         return;
     await this.config.runHook('recache', { type: 'update' });
 };
-exports.brewHook = brewHook;
+exports.default = doRecache;

package/lib/hooks/update/plugin-migrate.d.ts

@@ -1,2 +1,3 @@
 import { Hook } from '@oclif/core';
-export declare const migrate: Hook<'init'>;
+declare const migrate: Hook<'init'>;
+export default migrate;

package/lib/hooks/update/plugin-migrate.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrate = void 0;
-const tslib_1 = require("tslib");
-const fs = tslib_1.__importStar(require("fs-extra"));
-const path = tslib_1.__importStar(require("path"));
+const fs = require("fs-extra");
+const path = require("path");
 const exec = (cmd, args) => {
     const execa = require('execa');
     return execa(cmd, args, { stdio: 'inherit' });
@@ -57,4 +55,4 @@ const migrate = async function () {
     await removeYarnLockFile();
     await migrateV6Plugins();
 };
-exports.migrate = migrate;
+exports.default = migrate;

package/lib/hooks/update/tidy.d.ts

@@ -1,2 +1,3 @@
 import { Hook } from '@oclif/core';
-export declare const tidy: Hook<'update'>;
+declare const tidy: Hook<'update'>;
+export default tidy;

package/lib/hooks/update/tidy.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tidy = void 0;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const deps_1 = tslib_1.__importDefault(require("../../deps"));
+const path = require("path");
+const deps_1 = require("../../deps");
 const tidy = async function () {
     const cleanupPlugins = async () => {
         const pluginsDir = path.join(this.config.dataDir, 'plugins');
@@ -30,4 +28,4 @@ const tidy = async function () {
         await cleanupPlugins();
     }
 };
-exports.tidy = tidy;
+exports.default = tidy;

package/lib/lib/authorizations/authorizations.d.ts

@@ -0,0 +1,2 @@
+import * as Heroku from '@heroku-cli/schema';
+export declare function display(auth: Heroku.OAuthAuthorization): void;

package/lib/lib/authorizations/authorizations.js

@@ -0,0 +1,39 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.display = void 0;
+const core_1 = require("@oclif/core");
+const addSeconds = require("date-fns/add_seconds");
+const distanceInWordsToNow = require("date-fns/distance_in_words_to_now");
+function display(auth) {
+    const obj = {
+        ID: auth.id,
+        Description: auth.description,
+        Scope: auth.scope ? auth.scope.join(',') : undefined,
+        Client: '<none>',
+    };
+    if (auth.client) {
+        obj.Client = auth.client.name;
+        obj['Redirect URI'] = auth.client.redirect_uri;
+    }
+    if (auth.access_token) {
+        obj.Token = auth.access_token.token;
+        if (auth.updated_at) {
+            obj['Updated at'] = `${addSeconds(auth.updated_at, 0)} (${distanceInWordsToNow(auth.updated_at)} ago)`;
+        }
+        if (auth.access_token.expires_in) {
+            const date = addSeconds(new Date(), auth.access_token.expires_in);
+            obj['Expires at'] = `${date} (in ${distanceInWordsToNow(date)})`;
+        }
+    }
+    core_1.ux.styledObject(obj, [
+        'Client',
+        'Redirect URI',
+        'ID',
+        'Description',
+        'Scope',
+        'Token',
+        'Expires at',
+        'Updated at',
+    ]);
+}
+exports.display = display;

package/lib/lib/autocomplete/base.d.ts

@@ -0,0 +1,11 @@
+import Command from '@heroku-cli/command';
+import { Completion } from '@oclif/core/lib/interfaces/parser';
+export declare abstract class AutocompleteBase extends Command {
+    errorIfWindows(): void;
+    errorIfNotSupportedShell(shell: string): void;
+    get autocompleteCacheDir(): string;
+    get completionsCacheDir(): string;
+    get acLogfilePath(): string;
+    writeLogFile(msg: string): void;
+    protected findCompletion(cmdId: string, name: string, description?: string): Completion | undefined;
+}

package/lib/lib/autocomplete/base.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutocompleteBase = void 0;
+const command_1 = require("@heroku-cli/command");
+const fs = require("fs-extra");
+const path = require("path");
+const completions_1 = require("./completions");
+class AutocompleteBase extends command_1.default {
+    errorIfWindows() {
+        if (this.config.windows) {
+            throw new Error('Autocomplete is not currently supported in Windows');
+        }
+    }
+    errorIfNotSupportedShell(shell) {
+        if (!shell) {
+            this.error('Missing required argument shell');
+        }
+        this.errorIfWindows();
+        if (!['bash', 'zsh'].includes(shell)) {
+            throw new Error(`${shell} is not a supported shell for autocomplete`);
+        }
+    }
+    get autocompleteCacheDir() {
+        return path.join(this.config.cacheDir, 'autocomplete');
+    }
+    get completionsCacheDir() {
+        return path.join(this.config.cacheDir, 'autocomplete', 'completions');
+    }
+    get acLogfilePath() {
+        return path.join(this.config.cacheDir, 'autocomplete.log');
+    }
+    writeLogFile(msg) {
+        const now = new Date();
+        const entry = `[${now}] ${msg}\n`;
+        const fd = fs.openSync(this.acLogfilePath, 'a');
+        // eslint-disable-next-line
+        // @ts-ignore
+        fs.write(fd, entry);
+    }
+    findCompletion(cmdId, name, description = '') {
+        return new completions_1.CompletionLookup(cmdId, name, description).run();
+    }
+}
+exports.AutocompleteBase = AutocompleteBase;

package/lib/lib/autocomplete/cache.d.ts

@@ -0,0 +1,2 @@
+export declare function updateCache(cachePath: string, cache: any): Promise<void>;
+export declare function fetchCache(cachePath: string, cacheDuration: number, options: any): Promise<Array<string>>;

package/lib/lib/autocomplete/cache.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCache = exports.updateCache = void 0;
+const fs = require("fs-extra");
+async function updateCache(cachePath, cache) {
+    await fs.ensureFile(cachePath);
+    await fs.writeJSON(cachePath, cache);
+}
+exports.updateCache = updateCache;
+function _mtime(f) {
+    return fs.statSync(f).mtime;
+}
+function _isStale(cachePath, cacheDuration) {
+    const past = new Date();
+    past.setSeconds(past.getSeconds() - cacheDuration);
+    return past.getTime() > _mtime(cachePath).getTime();
+}
+async function fetchCache(cachePath, cacheDuration, options) {
+    const cachePresent = fs.existsSync(cachePath);
+    if (cachePresent && !_isStale(cachePath, cacheDuration)) {
+        return fs.readJSON(cachePath);
+    }
+    const cache = await options.cacheFn();
+    // to-do: move this to a fork
+    await updateCache(cachePath, cache);
+    return cache;
+}
+exports.fetchCache = fetchCache;