heroku 11.0.0-alpha.11 → 11.0.0-alpha.13

package/lib/lib/buildpacks/buildpacks.js

@@ -1,5 +1,5 @@
-import { color } from '@heroku-cli/color';
 import { BuildpackRegistry } from '@heroku/buildpack-registry';
+import { color } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
 import _ from 'lodash';
 import push from '../git/push.js';
@@ -20,15 +20,52 @@ export class BuildpackCommand {
         this.heroku = heroku;
         this.registry = new BuildpackRegistry();
     }
+    async clear(app, command, action) {
+        await this.put(app, []);
+        const configVars = await this.heroku.get(`/apps/${app}/config-vars`);
+        const message = `Buildpack${command === 'clear' ? 's' : ''} ${action}.`;
+        if (configVars.body.BUILDPACK_URL) {
+            ux.stdout(message);
+            ux.warn('The BUILDPACK_URL config var is still set and will be used for the next release');
+        }
+        else if (configVars.body.LANGUAGE_PACK_URL) {
+            ux.stdout(message);
+            ux.warn('The LANGUAGE_PACK_URL config var is still set and will be used for the next release');
+        }
+        else {
+            ux.stdout(`${message} Next release on ${color.app(app)} will detect buildpacks normally.`);
+        }
+    }
+    display(buildpacks, indent) {
+        if (buildpacks.length === 1) {
+            ux.stdout(this.registryUrlToName(buildpacks[0].buildpack.url, true));
+        }
+        else {
+            buildpacks.forEach((b, i) => {
+                ux.stdout(`${indent}${i + 1}. ${this.registryUrlToName(b.buildpack.url, true)}`);
+            });
+        }
+    }
+    displayUpdate(app, remote, buildpacks, action) {
+        if (buildpacks.length === 1) {
+            ux.stdout(`Buildpack ${action}. Next release on ${color.app(app)} will use ${this.registryUrlToName(buildpacks[0].buildpack.url)}.`);
+            ux.stdout(`Run ${color.code(push(remote))} to create a new release using this buildpack.`);
+        }
+        else {
+            ux.stdout(`Buildpack ${action}. Next release on ${color.app(app)} will use:`);
+            this.display(buildpacks, '  ');
+            ux.stdout(`Run ${color.code(push(remote))} to create a new release using these buildpacks.`);
+        }
+    }
     async fetch(app, isFirApp = false) {
         let buildpacks;
         if (isFirApp) {
             const { body: releases } = await this.heroku.request(`/apps/${app}/releases`, {
-                partial: true,
                 headers: {
-                    Range: 'version ..; max=10, order=desc',
                     Accept: 'application/vnd.heroku+json; version=3.sdk',
+                    Range: 'version ..; max=10, order=desc',
                 },
+                partial: true,
             });
             if (releases.length === 0 || releases[0].oci_image === null)
                 return [];
@@ -52,21 +89,37 @@ export class BuildpackCommand {
         }
         return this.mapBuildpackResponse(buildpacks);
     }
+    findIndex(buildpacks, index) {
+        if (index) {
+            return _.findIndex(buildpacks, (b) => b.ordinal + 1 === index);
+        }
+        return -1;
+    }
+    async findUrl(buildpacks, buildpack) {
+        const mappedUrl = await this.registryNameToUrl(buildpack);
+        return _.findIndex(buildpacks, (b) => b.buildpack.url === buildpack || b.buildpack.url === mappedUrl);
+    }
     mapBuildpackResponse(buildpacks) {
         return buildpacks.map((bp) => {
             bp.buildpack.url = bp.buildpack.url.replace(/^urn:buildpack:/, '');
             return bp;
         });
     }
-    display(buildpacks, indent) {
-        if (buildpacks.length === 1) {
-            ux.stdout(this.registryUrlToName(buildpacks[0].buildpack.url, true));
-        }
-        else {
-            buildpacks.forEach((b, i) => {
-                ux.stdout(`${indent}${i + 1}. ${this.registryUrlToName(b.buildpack.url, true)}`);
-            });
-        }
+    async mutate(app, buildpacks, spliceIndex, buildpack, command) {
+        const buildpackUpdates = buildpacks.map((b) => ({ buildpack: b.buildpack.url }));
+        const howmany = (command === 'add') ? 0 : 1;
+        const urls = (command === 'remove') ? [] : [{ buildpack: await this.registryNameToUrl(buildpack) }];
+        const indexes = [spliceIndex, howmany];
+        const array = indexes.concat(urls);
+        Array.prototype.splice.apply(buildpackUpdates, array);
+        return this.put(app, buildpackUpdates);
+    }
+    async put(app, buildpackUpdates) {
+        const { body: buildpacks } = await this.heroku.put(`/apps/${app}/buildpack-installations`, {
+            body: { updates: buildpackUpdates },
+            headers: { Range: '' },
+        });
+        return this.mapBuildpackResponse(buildpacks);
     }
     async registryNameToUrl(buildpack) {
         if (isValidURL(buildpack)) {
@@ -94,48 +147,6 @@ export class BuildpackCommand {
         }
         return '';
     }
-    async findUrl(buildpacks, buildpack) {
-        const mappedUrl = await this.registryNameToUrl(buildpack);
-        return _.findIndex(buildpacks, (b) => b.buildpack.url === buildpack || b.buildpack.url === mappedUrl);
-    }
-    async validateUrlNotSet(buildpacks, buildpack) {
-        if (await this.findUrl(buildpacks, buildpack) !== -1) {
-            ux.error(`The buildpack ${buildpack} is already set on your app.`, { exit: 1 });
-        }
-    }
-    findIndex(buildpacks, index) {
-        if (index) {
-            return _.findIndex(buildpacks, (b) => b.ordinal + 1 === index);
-        }
-        return -1;
-    }
-    async mutate(app, buildpacks, spliceIndex, buildpack, command) {
-        const buildpackUpdates = buildpacks.map((b) => ({ buildpack: b.buildpack.url }));
-        const howmany = (command === 'add') ? 0 : 1;
-        const urls = (command === 'remove') ? [] : [{ buildpack: await this.registryNameToUrl(buildpack) }];
-        const indexes = [spliceIndex, howmany];
-        const array = indexes.concat(urls);
-        Array.prototype.splice.apply(buildpackUpdates, array);
-        return this.put(app, buildpackUpdates);
-    }
-    async put(app, buildpackUpdates) {
-        const { body: buildpacks } = await this.heroku.put(`/apps/${app}/buildpack-installations`, {
-            headers: { Range: '' },
-            body: { updates: buildpackUpdates },
-        });
-        return this.mapBuildpackResponse(buildpacks);
-    }
-    displayUpdate(app, remote, buildpacks, action) {
-        if (buildpacks.length === 1) {
-            ux.stdout(`Buildpack ${action}. Next release on ${app} will use ${this.registryUrlToName(buildpacks[0].buildpack.url)}.`);
-            ux.stdout(`Run ${color.magenta(push(remote))} to create a new release using this buildpack.`);
-        }
-        else {
-            ux.stdout(`Buildpack ${action}. Next release on ${app} will use:`);
-            this.display(buildpacks, '  ');
-            ux.stdout(`Run ${color.magenta(push(remote))} to create a new release using these buildpacks.`);
-        }
-    }
     registryUrlToName(buildpack, registryOnly = false) {
         // eslint-disable-next-line no-useless-escape
         let match = /^https:\/\/buildpack\-registry\.s3\.amazonaws\.com\/buildpacks\/([\w\-]+\/[\w\-]+).tgz$/.exec(buildpack);
@@ -151,20 +162,9 @@ export class BuildpackCommand {
         }
         return buildpack;
     }
-    async clear(app, command, action) {
-        await this.put(app, []);
-        const configVars = await this.heroku.get(`/apps/${app}/config-vars`);
-        const message = `Buildpack${command === 'clear' ? 's' : ''} ${action}.`;
-        if (configVars.body.BUILDPACK_URL) {
-            ux.stdout(message);
-            ux.warn('The BUILDPACK_URL config var is still set and will be used for the next release');
-        }
-        else if (configVars.body.LANGUAGE_PACK_URL) {
-            ux.stdout(message);
-            ux.warn('The LANGUAGE_PACK_URL config var is still set and will be used for the next release');
-        }
-        else {
-            ux.stdout(`${message} Next release on ${app} will detect buildpacks normally.`);
+    validateIndex(index) {
+        if (Number.isNaN(index) || index <= 0) {
+            ux.error('Invalid index. Must be greater than 0.', { exit: 1 });
         }
     }
     validateIndexInRange(buildpacks, index) {
@@ -177,9 +177,9 @@ export class BuildpackCommand {
             }
         }
     }
-    validateIndex(index) {
-        if (Number.isNaN(index) || index <= 0) {
-            ux.error('Invalid index. Must be greater than 0.', { exit: 1 });
+    async validateUrlNotSet(buildpacks, buildpack) {
+        if (await this.findUrl(buildpacks, buildpack) !== -1) {
+            ux.error(`The buildpack ${buildpack} is already set on your app.`, { exit: 1 });
         }
     }
 }

package/lib/lib/certs/certificate_details.js

@@ -1,13 +1,12 @@
-import formatDate from './format_date.js';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
-import { color } from '@heroku-cli/color';
+import formatDate from './format_date.js';
 export const displayCertificateDetails = function (sniEndpoint, message = 'Certificate details:') {
     const now = new Date();
     const autoRenewsAt = new Date(sniEndpoint.ssl_cert.expires_at);
     autoRenewsAt.setMonth(autoRenewsAt.getMonth() - 1);
     if (sniEndpoint.app && sniEndpoint.ssl_cert.acm && autoRenewsAt > now) {
-        ux.stdout(`Renewal scheduled for ${color.green(formatDate(autoRenewsAt.toString()))}.\n`);
+        ux.stdout(`Renewal scheduled for ${color.info(formatDate(autoRenewsAt.toString()))}.\n`);
     }
     ux.stdout(message);
     const tableObject = {

package/lib/lib/certs/flags.d.ts

@@ -1,7 +1,7 @@
-import { SniEndpoint } from '../types/sni_endpoint.js';
 import { APIClient } from '@heroku-cli/command';
+import { SniEndpoint } from '../types/sni_endpoint.js';
 export default function (flags: {
+    app: string;
     endpoint: string | undefined;
     name: string | undefined;
-    app: string;
 }, heroku: APIClient): Promise<SniEndpoint>;

package/lib/lib/certs/flags.js

@@ -12,19 +12,16 @@ export default async function (flags, heroku) {
             endpoint.domains.forEach(domain => promises.push(heroku.get(`/apps/${flags.app}/domains/${domain}`)));
         });
         const domains = (await Promise.all(promises)).map(({ body: domain }) => domain);
-        sniEndpoints = sniEndpoints.filter(endpoint => {
-            // This was modified from `endpoint.cname === flags.endpoint` because `cname` doesn't exist anymore in the SniEndpoint serialization.
-            // We're making the assumption that the `--endpoint` flag was being used to search by hostname (internationalized domain name).
-            return domains.some(domain => domain.hostname === flags.endpoint && domain.sni_endpoint?.name === endpoint.name);
-        });
+        sniEndpoints = sniEndpoints.filter(endpoint => 
+        // This was modified from `endpoint.cname === flags.endpoint` because `cname` doesn't exist anymore in the SniEndpoint serialization.
+        // We're making the assumption that the `--endpoint` flag was being used to search by hostname (internationalized domain name).
+        domains.some(domain => domain.hostname === flags.endpoint && domain.sni_endpoint?.name === endpoint.name));
         if (sniEndpoints.length > 1) {
             throw new Error('Must pass --name when more than one endpoint matches --endpoint');
         }
     }
     if (flags.name) {
-        sniEndpoints = sniEndpoints.filter(endpoint => {
-            return endpoint.name === flags.name;
-        });
+        sniEndpoints = sniEndpoints.filter(endpoint => endpoint.name === flags.name);
         if (sniEndpoints.length > 1) {
             throw new Error(`More than one endpoint matches ${flags.name}, please file a support ticket`);
         }

package/lib/lib/certs/get_cert_and_key.js

@@ -2,8 +2,8 @@ import * as fs from 'node:fs/promises';
 export class CertAndKeyManager {
     async getCertAndKey(args) {
         return {
-            crt: await fs.readFile(args.CRT, { encoding: 'utf-8' }),
-            key: await fs.readFile(args.KEY, { encoding: 'utf-8' }),
+            crt: await fs.readFile(args.CRT, { encoding: 'utf8' }),
+            key: await fs.readFile(args.KEY, { encoding: 'utf8' }),
         };
     }
 }

package/lib/lib/ci/git.d.ts

@@ -3,8 +3,8 @@ declare function createArchive(ref: string): Promise<any>;
 declare function githubRepository(): Promise<gh.Result>;
 declare function readCommit(commit: string): Promise<{
     branch: string | undefined;
-    ref: string | undefined;
     message: string | undefined;
+    ref: string | undefined;
 }>;
 declare function sshGitUrl(app: string): string;
 declare function gitUrl(app?: string): string;
@@ -23,4 +23,14 @@ declare function listRemotes(): Promise<Map<string, {
 declare function inGitRepo(): true | undefined;
 declare function rmRemote(remote: string): Promise<void>;
 declare function createRemote(remote: string, url: string): Promise<string | null>;
-export { createArchive, githubRepository, readCommit, sshGitUrl, gitUrl, createRemote, listRemotes, rmRemote, inGitRepo, };
+export declare class GitService {
+    createArchive(ref: string): Promise<any>;
+    githubRepository(): Promise<gh.Result>;
+    readCommit(commit: string): Promise<{
+        branch: string | undefined;
+        message: string | undefined;
+        ref: string | undefined;
+    }>;
+}
+export declare const gitService: GitService;
+export { createArchive, createRemote, gitUrl, githubRepository, inGitRepo, listRemotes, readCommit, rmRemote, sshGitUrl, };

package/lib/lib/ci/git.js

@@ -1,7 +1,7 @@
-import fs from 'fs-extra';
 import { vars } from '@heroku-cli/command';
-import { spawn } from 'node:child_process';
+import fs from 'fs-extra';
 import gh from 'github-url-to-object';
+import { spawn } from 'node:child_process';
 import tmp from 'tmp';
 const NOT_A_GIT_REPOSITORY = 'not a git repository';
 const RUN_IN_A_GIT_REPOSITORY = 'Please run this command from the directory containing your project\'s git repo';
@@ -60,11 +60,11 @@ async function readCommit(commit) {
     const branch = await getBranch('HEAD');
     const ref = await getRef(commit);
     const message = await getCommitTitle(ref);
-    return Promise.resolve({
+    return {
         branch,
-        ref,
         message,
-    });
+        ref,
+    };
 }
 function sshGitUrl(app) {
     return `git@${vars.gitHost}:${app}.git`;
@@ -117,4 +117,18 @@ async function createRemote(remote, url) {
     }
     return null;
 }
-export { createArchive, githubRepository, readCommit, sshGitUrl, gitUrl, createRemote, listRemotes, rmRemote, inGitRepo, };
+// GitService class for easier testing/stubbing
+export class GitService {
+    async createArchive(ref) {
+        return createArchive(ref);
+    }
+    async githubRepository() {
+        return githubRepository();
+    }
+    async readCommit(commit) {
+        return readCommit(commit);
+    }
+}
+// Export a shared instance for use across commands
+export const gitService = new GitService();
+export { createArchive, createRemote, gitUrl, githubRepository, inGitRepo, listRemotes, readCommit, rmRemote, sshGitUrl, };

package/lib/lib/ci/pipelines.d.ts

@@ -4,17 +4,17 @@ import inquirer from 'inquirer';
 export declare class PipelineService {
     private herokuAPI;
     constructor(herokuAPI: APIClient);
+    disambiguatePipeline(pipelineIDOrName: string): Promise<any>;
+    getPipeline(flags: {
+        app: null | string;
+        pipeline: null | string;
+    }): Promise<any>;
     promptForPipeline(pipelineIDOrName: string, choices: {
         name: string;
         value: Heroku.Pipeline;
     }[]): Promise<any> & {
         ui: inquirer.ui.Prompt<any>;
     };
-    disambiguatePipeline(pipelineIDOrName: string): Promise<any>;
-    getPipeline(flags: {
-        pipeline: string | null;
-        app: string | null;
-    }): Promise<any>;
 }
 export declare function promptForPipeline(pipelineIDOrName: string, choices: {
     name: string;

package/lib/lib/ci/pipelines.js

@@ -1,22 +1,12 @@
-import inquirer from 'inquirer';
 import { ux } from '@oclif/core';
+import inquirer from 'inquirer';
 import { uuidValidate } from '../utils/uuid-validate.js';
 export class PipelineService {
     herokuAPI;
-    // eslint-disable-next-line no-useless-constructor
     constructor(herokuAPI) {
         this.herokuAPI = herokuAPI;
         // Constructor required to inject herokuAPI dependency
     }
-    promptForPipeline(pipelineIDOrName, choices) {
-        const questions = [{
-                type: 'list',
-                name: 'pipeline',
-                message: `Which ${pipelineIDOrName} pipeline?`,
-                choices,
-            }];
-        return inquirer.prompt(questions);
-    }
     async disambiguatePipeline(pipelineIDOrName) {
         const headers = { Accept: 'application/vnd.heroku+json; version=3.pipelines' };
         if (uuidValidate(pipelineIDOrName)) {
@@ -26,16 +16,17 @@ export class PipelineService {
         const { body: pipelines } = await this.herokuAPI.get(`/pipelines?eq[name]=${pipelineIDOrName}`, { headers });
         let choices;
         switch (pipelines.length) {
-            case 0:
+            case 0: {
                 ux.error('Pipeline not found');
                 break;
-            case 1:
+            }
+            case 1: {
                 return pipelines[0];
-            default:
-                choices = pipelines.map(function (x) {
-                    return { name: new Date(x.created_at), value: x };
-                });
+            }
+            default: {
+                choices = pipelines.map((x) => ({ name: new Date(x.created_at), value: x }));
                 return this.promptForPipeline(pipelineIDOrName, choices);
+            }
         }
     }
     async getPipeline(flags) {
@@ -60,6 +51,15 @@ export class PipelineService {
         }
         return pipeline;
     }
+    promptForPipeline(pipelineIDOrName, choices) {
+        const questions = [{
+                choices,
+                message: `Which ${pipelineIDOrName} pipeline?`,
+                name: 'pipeline',
+                type: 'list',
+            }];
+        return inquirer.prompt(questions);
+    }
 }
 // Export standalone functions for backward compatibility
 export function promptForPipeline(pipelineIDOrName, choices) {

package/lib/lib/ci/source.d.ts

@@ -1,2 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
 import { Command } from '@heroku-cli/command';
+export declare class FileService {
+    createReadStream(filePath: string): import("fs").ReadStream;
+    stat(filePath: string): Promise<import("fs").Stats>;
+}
+declare const fileService: FileService;
 export declare function createSourceBlob(ref: any, command: Command): Promise<any>;
+export { fileService };
+export { gitService } from './git.js';

package/lib/lib/ci/source.js

@@ -1,31 +1,40 @@
-import { promises as fs } from 'fs';
-import { createReadStream } from 'fs';
-import * as git from './git.js';
-import { got } from 'got';
 import debug from 'debug';
+import { createReadStream, promises as fs } from 'fs';
+import { got } from 'got';
+import { gitService } from './git.js';
 const ciDebug = debug('ci');
+// FileService class for easier testing/stubbing
+export class FileService {
+    createReadStream(filePath) {
+        return createReadStream(filePath);
+    }
+    async stat(filePath) {
+        return fs.stat(filePath);
+    }
+}
+const fileService = new FileService();
 async function uploadArchive(url, filePath) {
     const request = got.stream.put(url, {
         headers: {
-            'content-length': (await fs.stat(filePath)).size.toString(),
+            'content-length': (await fileService.stat(filePath)).size.toString(),
         },
     });
-    createReadStream(filePath).pipe(request);
+    fileService.createReadStream(filePath).pipe(request);
     return new Promise((resolve, reject) => {
         request.on('error', reject);
         request.on('response', resolve);
     });
 }
 async function prepareSource(ref, command) {
-    const filePath = await git.createArchive(ref);
+    const filePath = await gitService.createArchive(ref);
     const { body: source } = await command.heroku.post('/sources');
     await uploadArchive(source.source_blob.put_url, filePath);
-    return Promise.resolve(source);
+    return source;
 }
 export async function createSourceBlob(ref, command) {
     try {
-        const githubRepository = await git.githubRepository();
-        const { user, repo } = githubRepository;
+        const githubRepository = await gitService.githubRepository();
+        const { repo, user } = githubRepository;
         const { body: archiveLink } = await command.heroku.get(`https://kolkrabbi.heroku.com/github/repos/${user}/${repo}/tarball/${ref}`);
         if (await command.heroku.request(archiveLink.archive_link, { method: 'HEAD' })) {
             return archiveLink.archive_link;
@@ -38,3 +47,6 @@ export async function createSourceBlob(ref, command) {
     const sourceBlob = await prepareSource(ref, command);
     return sourceBlob.source_blob.get_url;
 }
+// Export service instances for testing
+export { fileService };
+export { gitService } from './git.js';

package/lib/lib/ci/test-run.js

@@ -1,13 +1,12 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
+import ansiEscapes from 'ansi-escapes';
+import debug from 'debug';
 import { get } from 'https';
 import { randomUUID } from 'node:crypto';
 import { Socket } from 'phoenix';
 import { inspect } from 'util';
 import WebSocket from 'ws';
-import debug from 'debug';
-import ansiEscapes from 'ansi-escapes';
 const ciDebug = debug('ci');
 const HEROKU_CI_WEBSOCKET_URL = process.env.HEROKU_CI_WEBSOCKET_URL || 'wss://particleboard.heroku.com/socket';
 function logStream(url, fn) {
@@ -30,7 +29,7 @@ function stream(url) {
 }
 function statusIcon({ status }) {
     if (!status) {
-        return color.yellow('-');
+        return color.info('-');
     }
     switch (status) {
         case 'pending':
@@ -38,22 +37,22 @@ function statusIcon({ status }) {
         case 'building':
         case 'running':
         case 'debugging': {
-            return color.yellow('-');
+            return color.info('-');
         }
         case 'errored': {
-            return color.red('!');
+            return color.failure('!');
         }
         case 'failed': {
-            return color.red('✗');
+            return color.failure('✗');
         }
         case 'succeeded': {
-            return color.green('✓');
+            return color.success('✓');
         }
         case 'cancelled': {
-            return color.yellow('!');
+            return color.warning('!');
         }
         default: {
-            return color.yellow('?');
+            return color.info('?');
         }
     }
 }
@@ -100,6 +99,7 @@ function draw(testRuns, watchOption = false, jsonOption = false, count = 15) {
     }
     const data = [];
     latestTestRuns.forEach(testRun => {
+        /* eslint-disable perfectionist/sort-objects */
         data.push({
             iconStatus: `${statusIcon(testRun)}`,
             number: testRun.number,
@@ -107,7 +107,9 @@ function draw(testRuns, watchOption = false, jsonOption = false, count = 15) {
             sha: testRun.commit_sha.slice(0, 7),
             status: testRun.status,
         });
+        /* eslint-enable perfectionist/sort-objects */
     });
+    /* eslint-disable perfectionist/sort-objects */
     hux.table(data, {
         iconStatus: {
             header: ' ', // header '' is to make sure that width is 1 character
@@ -119,6 +121,7 @@ function draw(testRuns, watchOption = false, jsonOption = false, count = 15) {
         sha: {},
         status: {},
     });
+    /* eslint-enable perfectionist/sort-objects */
     if (watchOption) {
         process.stdout.write(ansiEscapes.cursorUp(latestTestRuns.length));
     }
@@ -126,7 +129,7 @@ function draw(testRuns, watchOption = false, jsonOption = false, count = 15) {
 export async function renderList(command, testRuns, pipeline, watchOption, jsonOption) {
     const watchable = (Boolean(watchOption && !jsonOption));
     if (!jsonOption) {
-        const header = `${watchOption ? 'Watching' : 'Showing'} latest test runs for the ${pipeline.name} pipeline`;
+        const header = `${watchOption ? 'Watching' : 'Showing'} latest test runs for the ${color.pipeline(pipeline.name ?? '')} pipeline`;
         hux.styledHeader(header);
     }
     draw(testRuns, watchOption, jsonOption);
@@ -134,12 +137,12 @@ export async function renderList(command, testRuns, pipeline, watchOption, jsonO
         return;
     }
     const socket = new Socket(HEROKU_CI_WEBSOCKET_URL, {
-        transport: WebSocket,
+        logger: (kind, msg, data) => ciDebug(`${kind}: ${msg}\n${inspect(data)}`),
         params: {
-            token: command.heroku.auth,
             tab_id: `heroku-cli-${randomUUID()}`,
+            token: command.heroku.auth,
         },
-        logger: (kind, msg, data) => ciDebug(`${kind}: ${msg}\n${inspect(data)}`),
+        transport: WebSocket,
     });
     socket.connect();
     const channel = socket.channel(`events:pipelines/${pipeline.id}/test-runs`, {});

package/lib/lib/config/quote.js

@@ -4,11 +4,11 @@ export function quote(s) {
     // eslint-disable-next-line no-useless-escape
     if (/["\s#!$&'()*,:;<=>?@\[\\\]^`{|}]/.test(s)) {
         if (/['\n]/.test(s))
-            return '"' +
-                s
+            return '"'
+                + s
                     .replace(/(["\\$`!])/g, '\\$1')
-                    .replace(/\n/g, '\\n') +
-                '"';
+                    .replace(/\n/g, '\\n')
+                + '"';
         return "'" + s.replace(/(['\\])/g, '\\$1') + "'";
     }
     return s;

package/lib/lib/config/util.d.ts

@@ -1,3 +1,6 @@
 export declare class Editor {
     edit(input: string, options?: {}): Promise<string>;
 }
+export declare class EditorFactory {
+    static createEditor(): Editor;
+}

package/lib/lib/config/util.js

@@ -27,3 +27,8 @@ export class Editor {
         return result;
     }
 }
+export class EditorFactory {
+    static createEditor() {
+        return new Editor();
+    }
+}

package/lib/lib/confirmCommand.js

@@ -1,23 +1,22 @@
-import { color } from '@heroku-cli/color';
+import { color, hux } from '@heroku/heroku-cli-util';
 import { ux } from '@oclif/core';
-import { hux } from '@heroku/heroku-cli-util';
 export default class ConfirmCommand {
     async confirm(app, confirm, message) {
         if (confirm) {
             if (confirm === app)
                 return;
-            throw new Error(`Confirmation ${color.bold.red(confirm)} did not match ${color.bold.red(app)}. Aborted.`);
+            throw new Error(`Confirmation ${color.warning(confirm)} did not match ${color.info(app)}. Aborted.`);
         }
         if (!message) {
-            message = `WARNING: Destructive Action
-This command will affect the app ${color.bold.red(app)}`;
+            message = `Destructive Action
+This command will affect the app ${color.app(app)}`;
         }
         ux.warn(message);
         console.error();
-        const entered = await hux.prompt(`To proceed, type ${color.bold.red(app)} or re-run this command with ${color.bold.red('--confirm', app)}`, { required: true });
+        const entered = await hux.prompt(`To proceed, type ${color.warning(app)} or re-run this command with ${color.code('--confirm ' + app)}`, { required: true });
         if (entered === app) {
             return;
         }
-        throw new Error(`Confirmation did not match ${color.bold.red(app)}. Aborted.`);
+        throw new Error(`Confirmation did not match ${color.info(app)}. Aborted.`);
     }
 }