heroku 9.0.0-dev.0 → 9.0.0

package/lib/lib/certs/domains.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForDomains = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+function customDomainCreationComplete(app, heroku) {
+    return tslib_1.__asyncGenerator(this, arguments, function* customDomainCreationComplete_1() {
+        let retries = 30;
+        while (retries--) {
+            const { body: apiDomains } = yield tslib_1.__await(heroku.get(`/apps/${app}/domains`));
+            const someNull = apiDomains.some((domain) => domain.kind === 'custom' && !domain.cname);
+            if (!someNull) {
+                yield yield tslib_1.__await(apiDomains);
+                break;
+            }
+            yield tslib_1.__await(new Promise(resolve => {
+                setTimeout(resolve, 1000);
+            }));
+            yield yield tslib_1.__await(null);
+        }
+    });
+}
+async function waitForDomains(app, heroku) {
+    var e_1, _a;
+    core_1.ux.action.start('Waiting for stable domains to be created');
+    try {
+        for (var _b = tslib_1.__asyncValues(customDomainCreationComplete(app, heroku)), _c; _c = await _b.next(), !_c.done;) {
+            const apiDomains = _c.value;
+            if (apiDomains) {
+                core_1.ux.action.stop();
+                return apiDomains;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    core_1.ux.action.stop('!');
+    throw new Error('Timed out while waiting for stable domains to be created');
+}
+exports.waitForDomains = waitForDomains;

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

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

package/lib/lib/certs/flags.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function default_1(flags, heroku) {
+    if (flags.endpoint && flags.name) {
+        throw new Error('Specified both --name and --endpoint, please use just one');
+    }
+    let { body: sniEndpoints } = await heroku.get(`/apps/${flags.app}/sni-endpoints`);
+    if (sniEndpoints.length === 0) {
+        throw new Error(`${flags.app} has no SSL certificates`);
+    }
+    if (flags.endpoint) {
+        const promises = [];
+        sniEndpoints.forEach(endpoint => {
+            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 => { var _a; return domain.hostname === flags.endpoint && ((_a = domain.sni_endpoint) === null || _a === void 0 ? void 0 : _a.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;
+        });
+        if (sniEndpoints.length > 1) {
+            throw new Error(`More than one endpoint matches ${flags.name}, please file a support ticket`);
+        }
+    }
+    if (sniEndpoints.length > 1) {
+        throw new Error('Must pass --name when more than one endpoint');
+    }
+    if (sniEndpoints.length === 0) {
+        throw new Error('Record not found.');
+    }
+    return sniEndpoints[0];
+}
+exports.default = default_1;

package/lib/lib/certs/format_date.d.ts

@@ -0,0 +1 @@
+export default function (date: string): string;

package/lib/lib/certs/format_date.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_fns_1 = require("date-fns");
+function getUTCDate(dateString = Date.now()) {
+    const date = new Date(dateString);
+    return new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds());
+}
+function default_1(date) {
+    return `${(0, date_fns_1.format)(getUTCDate(date), 'yyyy-MM-dd HH:mm')} UTC`;
+}
+exports.default = default_1;

package/lib/lib/certs/get_cert_and_key.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import type { PathLike } from 'node:fs';
+export declare function getCertAndKey(args: {
+    CRT: PathLike;
+    KEY: PathLike;
+}): Promise<{
+    crt: string;
+    key: string;
+}>;

package/lib/lib/certs/get_cert_and_key.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCertAndKey = void 0;
+const fs = require("node:fs/promises");
+async function getCertAndKey(args) {
+    return {
+        crt: await fs.readFile(args.CRT, { encoding: 'utf-8' }),
+        key: await fs.readFile(args.KEY, { encoding: 'utf-8' }),
+    };
+}
+exports.getCertAndKey = getCertAndKey;

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

@@ -5,4 +5,10 @@ declare function readCommit(commit: string): Promise<{
     ref: string | undefined;
     message: string | undefined;
 }>;
-export { createArchive, githubRepository, readCommit, };
+declare function sshGitUrl(app: string): string;
+declare function gitUrl(app?: string): string;
+declare function listRemotes(): Promise<string[][]>;
+declare function inGitRepo(): true | undefined;
+declare function rmRemote(remote: string): Promise<string>;
+declare function createRemote(remote: string, url: string): Promise<string | null>;
+export { createArchive, githubRepository, readCommit, sshGitUrl, gitUrl, createRemote, listRemotes, rmRemote, inGitRepo, };

package/lib/lib/ci/git.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readCommit = exports.githubRepository = exports.createArchive = void 0;
+exports.inGitRepo = exports.rmRemote = exports.listRemotes = exports.createRemote = exports.gitUrl = exports.sshGitUrl = exports.readCommit = exports.githubRepository = exports.createArchive = void 0;
 const fs = require("fs-extra");
+const command_1 = require("@heroku-cli/command");
 const gh = require('github-url-to-object');
 const spawn = require('child_process').spawn;
 const tmp = require('tmp');
@@ -69,3 +70,45 @@ async function readCommit(commit) {
     });
 }
 exports.readCommit = readCommit;
+function sshGitUrl(app) {
+    return `git@${command_1.vars.gitHost}:${app}.git`;
+}
+exports.sshGitUrl = sshGitUrl;
+function gitUrl(app) {
+    return `https://${command_1.vars.httpGitHost}/${app}.git`;
+}
+exports.gitUrl = gitUrl;
+async function listRemotes() {
+    return runGit('remote', '-v').then(remotes => remotes.trim().split('\n').map(r => r.split(/\s/)));
+}
+exports.listRemotes = listRemotes;
+function inGitRepo() {
+    try {
+        fs.lstatSync('.git');
+        return true;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+exports.inGitRepo = inGitRepo;
+function rmRemote(remote) {
+    return runGit('remote', 'rm', remote);
+}
+exports.rmRemote = rmRemote;
+function hasGitRemote(remote) {
+    return runGit('remote')
+        .then(remotes => remotes.split('\n'))
+        .then(remotes => remotes.find(r => r === remote));
+}
+function createRemote(remote, url) {
+    return hasGitRemote(remote)
+        .then(exists => {
+        if (!exists) {
+            return runGit('remote', 'add', remote, url);
+        }
+        return null;
+    });
+}
+exports.createRemote = createRemote;

package/lib/lib/ci/interfaces/kolkrabbi.d.ts

@@ -186,7 +186,7 @@ export interface HerokuPlatformApiOrganization {
     [k: string]: any;
 }
 /**
- * Pipeline repositories link a pipeline to a Github repository.
+ * Pipeline repositories link a pipeline to a GitHub repository.
  */
 export interface KolkrabbiApiPipelineRepositories {
     /**

package/lib/lib/ci/source.js

@@ -4,11 +4,11 @@ exports.createSourceBlob = void 0;
 const fs = require("async-file");
 const core_1 = require("@oclif/core");
 const git = require("./git");
-const got = require('got');
+const got_1 = require("got");
 async function uploadArchive(url, filePath) {
-    const request = got.stream.put(url, {
+    const request = got_1.default.stream.put(url, {
         headers: {
-            'content-length': (await fs.stat(filePath)).size,
+            'content-length': (await fs.stat(filePath)).size.toString(),
         },
     });
     fs.createReadStream(filePath).pipe(request);

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

@@ -4,9 +4,9 @@ exports.displayTestRunInfo = exports.displayAndExit = exports.waitForStates = ex
 const color_1 = require("@heroku-cli/color");
 const core_1 = require("@oclif/core");
 const https_1 = require("https");
+const node_crypto_1 = require("node:crypto");
 const phoenix_1 = require("phoenix");
 const util_1 = require("util");
-const uuid_1 = require("uuid");
 const WebSocket = require("ws");
 const debug = require('debug')('ci');
 const ansiEscapes = require('ansi-escapes');
@@ -132,7 +132,7 @@ async function renderList(command, testRuns, pipeline, watchOption, jsonOption)
         transport: WebSocket,
         params: {
             token: command.heroku.auth,
-            tab_id: `heroku-cli-${(0, uuid_1.v4)()}`,
+            tab_id: `heroku-cli-${(0, node_crypto_1.randomUUID)()}`,
         },
         logger: (kind, msg, data) => debug(`${kind}: ${msg}\n${(0, util_1.inspect)(data)}`),
     });

package/lib/lib/config/quote.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = exports.quote = void 0;
 const shell = require('shell-quote');
-// slightly modifed form of shell-quote to default to using single-quotes over backslashes
+// slightly modified form of shell-quote to default to using single-quotes over backslashes
 function quote(s) {
     // eslint-disable-next-line no-useless-escape
     if (/["\s#!$&'()*,:;<=>?@\[\\\]^`{|}]/.test(s)) {

package/lib/lib/confirmCommand.d.ts

@@ -0,0 +1 @@
+export default function confirmCommand(app: string, confirm?: string, message?: string): Promise<void>;

package/lib/lib/confirmCommand.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+async function confirmCommand(app, confirm, message) {
+    if (confirm) {
+        if (confirm === app)
+            return;
+        throw new Error(`Confirmation ${color_1.default.bold.red(confirm)} did not match ${color_1.default.bold.red(app)}. Aborted.`);
+    }
+    if (!message) {
+        message = `WARNING: Destructive Action
+This command will affect the app ${color_1.default.bold.red(app)}`;
+    }
+    core_1.ux.warn(message);
+    console.error();
+    const entered = await core_1.ux.prompt(`To proceed, type ${color_1.default.bold.red(app)} or re-run this command with ${color_1.default.bold.red('--confirm', app)}`, { required: true });
+    if (entered === app) {
+        return;
+    }
+    throw new Error(`Confirmation did not match ${color_1.default.bold.red(app)}. Aborted.`);
+}
+exports.default = confirmCommand;

package/lib/lib/container/debug.d.ts

@@ -0,0 +1,2 @@
+import * as logger from 'debug';
+export declare const debug: logger.Debugger;

package/lib/lib/container/debug.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = void 0;
+const logger = require("debug");
+exports.debug = logger('heroku-container-registry');

package/lib/lib/container/docker_helper.d.ts

@@ -0,0 +1,24 @@
+export declare type cmdOptions = {
+    output?: boolean;
+    input?: string;
+};
+export declare const cmd: (cmd: string, args: string[], options?: cmdOptions) => Promise<string>;
+export declare const version: () => Promise<number[]>;
+export declare const pullImage: (resource: string) => Promise<string>;
+export declare const getDockerfiles: (rootdir: string, recursive: boolean) => string[];
+export declare type dockerJob = {
+    name: string;
+    resource: string;
+    dockerfile: string;
+    postfix: number;
+    depth: number;
+};
+export declare type groupedDockerJobs = {
+    [processType: string]: dockerJob[];
+};
+export declare const getJobs: (resourceRoot: string, dockerfiles: string[]) => groupedDockerJobs;
+export declare const filterByProcessType: (jobs: groupedDockerJobs, processTypes: string[]) => groupedDockerJobs;
+export declare const chooseJobs: (jobs: groupedDockerJobs) => Promise<dockerJob[]>;
+export declare const buildImage: (dockerfile: string, resource: string, buildArgs: string[], path?: string) => Promise<string>;
+export declare const pushImage: (resource: string) => Promise<string>;
+export declare const runImage: (resource: string, command: string, port: number) => Promise<string>;

package/lib/lib/container/docker_helper.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runImage = exports.pushImage = exports.buildImage = exports.chooseJobs = exports.filterByProcessType = exports.getJobs = exports.getDockerfiles = exports.pullImage = exports.version = exports.cmd = void 0;
+const Child = require("child_process");
+const debug_1 = require("./debug");
+const glob = require("glob");
+const Path = require("path");
+const inquirer = require("inquirer");
+const os = require("os");
+const DOCKERFILE_REGEX = /\bDockerfile(.\w*)?$/;
+const cmd = async function (cmd, args, options = {}) {
+    (0, debug_1.debug)(cmd, args);
+    const stdio = [
+        options.input ? 'pipe' : process.stdin,
+        options.output ? 'pipe' : process.stdout,
+        process.stderr,
+    ];
+    return new Promise((resolve, reject) => {
+        const child = Child.spawn(cmd, args, { stdio: stdio });
+        if (child.stdin) {
+            child.stdin.end(options.input);
+        }
+        let stdout;
+        if (child.stdout) {
+            stdout = '';
+            child.stdout.on('data', data => {
+                stdout += data.toString();
+            });
+        }
+        child.on('error', (err) => {
+            if (err.code === 'ENOENT' && err.path === 'docker') {
+                reject(new Error(`Cannot find docker, please ensure docker is installed.
+        If you need help installing docker, visit https://docs.docker.com/install/#supported-platforms`));
+            }
+            else {
+                reject(err);
+            }
+        });
+        child.on('exit', (code, signal) => {
+            if (signal || code) {
+                reject(new Error(signal || (code === null || code === void 0 ? void 0 : code.toString())));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+};
+exports.cmd = cmd;
+const version = async function () {
+    const version = await (0, exports.cmd)('docker', ['version', '-f', '{{.Client.Version}}'], { output: true });
+    const [major, minor] = version.split(/\./);
+    return [Number.parseInt(major, 10) || 0, Number.parseInt(minor, 10) || 0]; // ensure exactly 2 components
+};
+exports.version = version;
+const pullImage = function (resource) {
+    const args = ['pull', resource];
+    return (0, exports.cmd)('docker', args);
+};
+exports.pullImage = pullImage;
+const getDockerfiles = function (rootdir, recursive) {
+    const match = recursive ? './**/Dockerfile?(.)*' : 'Dockerfile*';
+    let dockerfiles = glob.sync(match, {
+        cwd: rootdir,
+        nodir: true,
+    });
+    if (recursive) {
+        dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile\.[\w]+$/));
+    }
+    else {
+        dockerfiles = dockerfiles.filter(df => df.match(/Dockerfile$/));
+    }
+    return dockerfiles.map(file => Path.join(rootdir, file));
+};
+exports.getDockerfiles = getDockerfiles;
+const getJobs = function (resourceRoot, dockerfiles) {
+    const jobs = [];
+    dockerfiles.forEach(dockerfile => {
+        const match = dockerfile.match(DOCKERFILE_REGEX);
+        if (match) {
+            const proc = (match[1] || '.standard').slice(1);
+            jobs.push({
+                name: proc,
+                resource: `${resourceRoot}/${proc}`,
+                dockerfile: dockerfile,
+                postfix: Path.basename(dockerfile) === 'Dockerfile' ? 0 : 1,
+                depth: Path.normalize(dockerfile).split(Path.sep).length,
+            });
+        }
+    });
+    // prefer closer Dockerfiles, then prefer Dockerfile over Dockerfile.web
+    jobs.sort((a, b) => {
+        return a.depth - b.depth || a.postfix - b.postfix;
+    });
+    // group all Dockerfiles for the same process type together
+    const groupedJobs = {};
+    jobs.forEach(job => {
+        groupedJobs[job.name] = groupedJobs[job.name] || [];
+        groupedJobs[job.name].push(job);
+    });
+    return groupedJobs;
+};
+exports.getJobs = getJobs;
+const filterByProcessType = function (jobs, processTypes) {
+    const filteredJobs = {};
+    processTypes.forEach(processType => {
+        filteredJobs[processType] = jobs[processType];
+    });
+    return filteredJobs;
+};
+exports.filterByProcessType = filterByProcessType;
+const chooseJobs = async function (jobs) {
+    const chosenJobs = [];
+    for (const processType in jobs) {
+        if (Object.prototype.hasOwnProperty.call(jobs, processType)) {
+            const group = jobs[processType];
+            if (group.length > 1) {
+                const prompt = [{
+                        type: 'list',
+                        name: processType,
+                        choices: group.map(j => j.dockerfile),
+                        message: `Found multiple Dockerfiles with process type ${processType}. Please choose one to build and push `,
+                    }];
+                const answer = await inquirer.prompt(prompt);
+                const found = group.find(o => o.dockerfile === answer[processType]);
+                if (found) {
+                    chosenJobs.push(found);
+                }
+            }
+            else {
+                chosenJobs.push(group[0]);
+            }
+        }
+    }
+    return chosenJobs;
+};
+exports.chooseJobs = chooseJobs;
+const buildImage = async function (dockerfile, resource, buildArgs, path) {
+    const cwd = path || Path.dirname(dockerfile);
+    const args = ['build', '-f', dockerfile, '-t', resource, '--platform', 'linux/amd64'];
+    for (const element of buildArgs) {
+        if (element.length > 0) {
+            args.push('--build-arg', element);
+        }
+    }
+    args.push(cwd);
+    return (0, exports.cmd)('docker', args);
+};
+exports.buildImage = buildImage;
+const pushImage = async function (resource) {
+    const args = ['push', resource];
+    return (0, exports.cmd)('docker', args);
+};
+exports.pushImage = pushImage;
+const runImage = function (resource, command, port) {
+    const args = [
+        'run',
+        '--user',
+        os.userInfo().uid.toString(),
+        '-e',
+        `PORT=${port}`,
+        '-it',
+        resource,
+        command,
+    ];
+    return (0, exports.cmd)('docker', args);
+};
+exports.runImage = runImage;

package/lib/lib/container/helpers.d.ts

@@ -0,0 +1,8 @@
+import * as Heroku from '@heroku-cli/schema';
+/**
+ * Ensure that the given app is a container app.
+ * @param app {Heroku.App} heroku app
+ * @param cmd {String} command name
+ * @returns {null} null
+ */
+export declare function ensureContainerStack(app: Heroku.App, cmd: string): void;

package/lib/lib/container/helpers.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureContainerStack = void 0;
+const color_1 = require("@heroku-cli/color");
+const core_1 = require("@oclif/core");
+const stackLabelMap = {
+    cnb: 'Cloud Native Buildpack',
+};
+/**
+ * Ensure that the given app is a container app.
+ * @param app {Heroku.App} heroku app
+ * @param cmd {String} command name
+ * @returns {null} null
+ */
+function ensureContainerStack(app, cmd) {
+    var _a, _b, _c;
+    if (((_a = app.stack) === null || _a === void 0 ? void 0 : _a.name) !== 'container') {
+        const appLabel = (((_b = app.stack) === null || _b === void 0 ? void 0 : _b.name) && stackLabelMap[app.stack.name]) || ((_c = app.stack) === null || _c === void 0 ? void 0 : _c.name);
+        let message = 'This command is for Docker apps only.';
+        if (['push', 'release'].includes(cmd)) {
+            message += ` Run ${color_1.default.cyan('git push heroku main')} to deploy your ${color_1.default.cyan(app.name)} ${color_1.default.cyan(appLabel)} app instead.`;
+        }
+        core_1.ux.error(message, { exit: 1 });
+    }
+}
+exports.ensureContainerStack = ensureContainerStack;

package/lib/lib/container/streamer.d.ts

@@ -0,0 +1 @@
+export declare const streamer: (url: string, out: NodeJS.WriteStream) => Promise<unknown>;

package/lib/lib/container/streamer.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamer = void 0;
+async function call(url, out, retries) {
+    const http = require('http-call').HTTP;
+    const maxRetries = 30;
+    try {
+        const { response } = await http.stream(url);
+        response.on('data', function (d) {
+            out.write(d);
+        });
+        return await new Promise(function (resolve, reject) {
+            response.on('error', reject);
+            response.on('end', resolve);
+        });
+    }
+    catch (error) {
+        if (error.statusCode === 404 && retries <= maxRetries) {
+            return new Promise(function (resolve, reject) {
+                setTimeout(function () {
+                    call(url, out, retries + 1).then(resolve, reject);
+                }, 1000);
+            });
+        }
+        throw error;
+    }
+}
+const streamer = function (url, out) {
+    return call(url, out, 0);
+};
+exports.streamer = streamer;

package/lib/lib/domains/domains.d.ts

@@ -0,0 +1,6 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+export declare function getDomains(heroku: APIClient, app: string): Promise<Required<Heroku.Domain>[]>;
+export declare function waitForDomains(heroku: APIClient, app: string): Promise<Required<Heroku.Domain>[]>;
+export declare function printDomains(domains: Required<Heroku.Domain>[], message: string): void;
+export declare function waitForCertIssuedOnDomains(heroku: APIClient, app: string): Promise<void>;