heroku 11.0.0-alpha.1 → 11.0.0-alpha.10

package/lib/commands/pipelines/destroy.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class PipelinesDestroy extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        pipeline: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/destroy.js

@@ -0,0 +1,24 @@
+import { color } from '@heroku-cli/color';
+import { Command } from '@heroku-cli/command';
+import { Args, ux } from '@oclif/core';
+import { destroyPipeline } from '../../lib/api.js';
+import disambiguate from '../../lib/pipelines/disambiguate.js';
+export default class PipelinesDestroy extends Command {
+    static description = 'destroy a pipeline';
+    static examples = [
+        '$ heroku pipelines:destroy my-pipeline',
+    ];
+    static args = {
+        pipeline: Args.string({
+            description: 'name of pipeline',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(PipelinesDestroy);
+        const pipeline = await disambiguate(this.heroku, args.pipeline);
+        ux.action.start(`Destroying ${color.pipeline(pipeline.name)} pipeline`);
+        await destroyPipeline(this.heroku, pipeline.name, pipeline.id);
+        ux.action.stop();
+    }
+}

package/lib/commands/pipelines/diff.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@heroku-cli/command';
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api.js';
+import { GenerationKind } from '../../lib/apps/generation.js';
+interface AppInfo {
+    name: string;
+    repo?: string;
+    hash?: string;
+}
+export default class PipelinesDiff extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        app: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        remote: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    kolkrabbi: KolkrabbiAPI;
+    getAppInfo: (appName: string, appId: string, generation: GenerationKind) => Promise<AppInfo>;
+    run(): Promise<undefined>;
+}
+export {};

package/lib/commands/pipelines/diff.js

@@ -0,0 +1,156 @@
+import { color } from '@heroku-cli/color';
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import { HTTP } from '@heroku/http-call';
+import { getCoupling, getPipeline, getReleases, listPipelineApps, SDK_HEADER } from '../../lib/api.js';
+import KolkrabbiAPI from '../../lib/pipelines/kolkrabbi-api.js';
+import { getGeneration } from '../../lib/apps/generation.js';
+const PROMOTION_ORDER = ['development', 'staging', 'production'];
+async function diff(targetApp, downstreamApp, githubToken, herokuUserAgent) {
+    if (!downstreamApp.repo) {
+        return ux.stdout(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} as ${color.app(downstreamApp.name)} is not connected to GitHub`);
+    }
+    if (downstreamApp.repo !== targetApp.repo) {
+        return ux.stdout(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} as ${color.app(downstreamApp.name)} is not connected to the same GitHub repo as ${color.app(targetApp.name)}`);
+    }
+    if (!downstreamApp.hash) {
+        return ux.stdout(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} as ${color.app(downstreamApp.name)} does not have any releases`);
+    }
+    if (downstreamApp.hash === targetApp.hash) {
+        return ux.stdout(`\n${color.app(targetApp.name)} is up to date with ${color.app(downstreamApp.name)}`);
+    }
+    // Do the actual GitHub diff
+    try {
+        const path = `${targetApp.repo}/compare/${downstreamApp.hash}...${targetApp.hash}`;
+        const headers = {
+            authorization: 'token ' + githubToken,
+            'Content-Type': 'application/vnd.github+json',
+            'X-GitHub-Api-Version': '2022-11-28',
+        };
+        if (herokuUserAgent) {
+            Reflect.set(headers, 'user-agent', herokuUserAgent);
+        }
+        const { body: githubDiff } = await HTTP.get(`https://api.github.com/repos/${path}`, { headers });
+        ux.stdout('');
+        hux.styledHeader(`${color.app(targetApp.name)} is ahead of ${color.app(downstreamApp.name)} by ${githubDiff.ahead_by} commit${githubDiff.ahead_by === 1 ? '' : 's'}`);
+        const mapped = githubDiff.commits.map((commit) => ({
+            sha: commit.sha.slice(0, 7),
+            date: commit.commit.author.date,
+            author: commit.commit.author.name,
+            message: commit.commit.message.split('\n')[0],
+        })).reverse();
+        hux.table(mapped, {
+            sha: {
+                header: 'SHA',
+            },
+            date: {},
+            author: {},
+            message: {},
+        });
+        ux.stdout(`\nhttps://github.com/${path}`);
+    }
+    catch {
+        ux.stdout(`\n${color.app(targetApp.name)} was not compared to ${color.app(downstreamApp.name)} because we were unable to perform a diff`);
+        ux.stdout('are you sure you have pushed your latest commits to GitHub?');
+    }
+}
+export default class PipelinesDiff extends Command {
+    static description = 'compares the latest release of this app to its downstream app(s)';
+    static examples = [
+        '$ heroku pipelines:diff -a my-app-staging',
+    ];
+    static flags = {
+        app: flags.app({ required: true }),
+        remote: flags.remote(),
+    };
+    kolkrabbi = new KolkrabbiAPI(this.config.userAgent, () => this.heroku.auth);
+    getAppInfo = async (appName, appId, generation) => {
+        // Find GitHub connection for the app
+        const githubApp = await this.kolkrabbi.getAppLink(appId)
+            .catch(() => ({ name: appName, repo: null, hash: null }));
+        // Find the commit hash of the latest release for this app
+        let slug;
+        let ociImages;
+        let commit;
+        try {
+            const { body: releases } = await getReleases(this.heroku, appId);
+            const release = releases.find(r => r.status === 'succeeded');
+            if (!release || !(release.slug || release.oci_image)) {
+                throw new Error(`no release found for ${appName}`);
+            }
+            if (generation === 'cedar' && release.slug) {
+                slug = await this.heroku.get(`/apps/${appId}/slugs/${release.slug.id}`, {
+                    headers: { Accept: SDK_HEADER },
+                }).then(res => res.body);
+                commit = slug.commit;
+            }
+            else if (generation === 'fir' && release.oci_image) {
+                ociImages = await this.heroku.get(`/apps/${appId}/oci-images/${release.oci_image.id}`, {
+                    headers: { Accept: SDK_HEADER },
+                }).then(res => res.body);
+                commit = ociImages[0]?.commit;
+            }
+        }
+        catch {
+            return { name: appName, repo: githubApp.repo, hash: undefined };
+        }
+        return { name: appName, repo: githubApp.repo, hash: commit };
+    };
+    async run() {
+        const { flags } = await this.parse(PipelinesDiff);
+        const targetAppName = flags.app;
+        let coupling;
+        try {
+            ({ body: coupling } = await getCoupling(this.heroku, targetAppName));
+        }
+        catch {
+            ux.error(`This app (${targetAppName}) does not seem to be a part of any pipeline`);
+            return;
+        }
+        const { body: pipeline } = await getPipeline(this.heroku, coupling.pipeline.id);
+        const targetAppId = coupling.app.id;
+        const generation = getGeneration(pipeline);
+        ux.action.start('Fetching apps from pipeline');
+        const allApps = await listPipelineApps(this.heroku, coupling.pipeline.id);
+        ux.action.stop();
+        const sourceStage = coupling.stage;
+        if (!sourceStage) {
+            return ux.error(`Unable to diff ${targetAppName}`);
+        }
+        const downstreamStage = PROMOTION_ORDER[PROMOTION_ORDER.indexOf(sourceStage) + 1];
+        if (!downstreamStage || !PROMOTION_ORDER.includes(sourceStage)) {
+            return ux.error(`Unable to diff ${targetAppName}`);
+        }
+        const downstreamApps = allApps.filter(app => app.pipelineCoupling.stage === downstreamStage);
+        if (downstreamApps.length === 0) {
+            return ux.error(`Cannot diff ${targetAppName} as there are no downstream apps configured`);
+        }
+        // Fetch GitHub repo/latest release hash for [target, downstream[0], .., downstream[n]] apps
+        const appInfoPromises = [this.getAppInfo(targetAppName, targetAppId, generation)];
+        downstreamApps.forEach(app => {
+            if (app.name && app.id) {
+                appInfoPromises.push(this.getAppInfo(app.name, app.id, generation));
+            }
+        });
+        ux.action.start('Fetching release info for all apps');
+        const appInfo = await Promise.all(appInfoPromises);
+        ux.action.stop();
+        // Verify the target app
+        const targetAppInfo = appInfo[0];
+        if (!targetAppInfo.repo) {
+            const command = `heroku pipelines:open ${coupling.pipeline.name}`;
+            return ux.error(`${targetAppName} does not seem to be connected to GitHub!\nRun ${color.cyan(command)} and "Connect to GitHub".`);
+        }
+        if (!targetAppInfo.hash) {
+            return ux.error(`No release was found for ${targetAppName}, unable to diff`);
+        }
+        // Fetch GitHub token for the user
+        const githubAccount = await this.kolkrabbi.getAccount();
+        // Diff [{target, downstream[0]}, {target, downstream[1]}, .., {target, downstream[n]}]
+        const downstreamAppsInfo = appInfo.slice(1);
+        for (const downstreamAppInfo of downstreamAppsInfo) {
+            await diff(targetAppInfo, downstreamAppInfo, githubAccount.github.token, this.config.userAgent);
+        }
+    }
+}

package/lib/commands/pipelines/index.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@heroku-cli/command';
+export default class Pipelines extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/index.js

@@ -0,0 +1,25 @@
+import { Command, flags } from '@heroku-cli/command';
+import { ux } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+export default class Pipelines extends Command {
+    static description = 'list pipelines you have access to';
+    static examples = [
+        '$ heroku pipelines',
+    ];
+    static flags = {
+        json: flags.boolean({ description: 'output in json format' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Pipelines);
+        const { body: pipelines } = await this.heroku.get('/pipelines');
+        if (flags.json) {
+            hux.styledJSON(pipelines);
+        }
+        else {
+            hux.styledHeader('My Pipelines');
+            for (const pipeline of pipelines) {
+                ux.stdout(pipeline.name);
+            }
+        }
+    }
+}

package/lib/commands/pipelines/info.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@heroku-cli/command';
+export default class PipelinesInfo extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'with-owners': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        pipeline: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/pipelines/info.js

@@ -0,0 +1,41 @@
+import { Command, flags } from '@heroku-cli/command';
+import { Args } from '@oclif/core';
+import { hux } from '@heroku/heroku-cli-util';
+import { listPipelineApps } from '../../lib/api.js';
+import disambiguate from '../../lib/pipelines/disambiguate.js';
+import renderPipeline from '../../lib/pipelines/render-pipeline.js';
+export default class PipelinesInfo extends Command {
+    static description = 'show list of apps in a pipeline';
+    static examples = [
+        '$ heroku pipelines:info my-pipeline',
+    ];
+    static flags = {
+        json: flags.boolean({
+            description: 'output in json format',
+        }),
+        'with-owners': flags.boolean({
+            description: 'shows owner of every app',
+            hidden: true,
+        }),
+    };
+    static args = {
+        pipeline: Args.string({
+            description: 'pipeline to show list of apps for',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(PipelinesInfo);
+        const pipeline = await disambiguate(this.heroku, args.pipeline);
+        const pipelineApps = await listPipelineApps(this.heroku, pipeline.id);
+        if (flags.json) {
+            hux.styledJSON({ pipeline, apps: pipelineApps });
+        }
+        else {
+            await renderPipeline(this.heroku, pipeline, pipelineApps, {
+                withOwners: flags['with-owners'],
+                showOwnerWarning: true,
+            });
+        }
+    }
+}

package/lib/lib/local/env-file-validator.d.ts

@@ -0,0 +1 @@
+export declare function validateEnvFile(envFile: string | undefined, warn: (message: string) => void): string;

package/lib/lib/local/env-file-validator.js

@@ -0,0 +1,10 @@
+import * as fs from 'fs';
+import { color } from '@heroku-cli/color';
+export function validateEnvFile(envFile, warn) {
+    const resolvedEnvFile = envFile || '.env';
+    if (fs.existsSync(resolvedEnvFile) && !fs.statSync(resolvedEnvFile).isFile()) {
+        warn(`The specified location for the env file, ${color.bold(resolvedEnvFile)}, is not a file, ignoring.`);
+        return '';
+    }
+    return resolvedEnvFile;
+}

package/lib/lib/local/fork-foreman.js

@@ -1,13 +1,20 @@
 import { fork as forkChildProcess } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
+import { fileURLToPath } from 'url';
 // depending if this is being ran before or after compilation
 // we need to check for `.ts` and `.js` extensions and use
 // the appropriate one.
 function getForemanScriptPath() {
     const file = 'run-foreman';
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const withCjsExtension = path.join(__dirname, file + '.cjs');
     const withJsExtension = path.join(__dirname, file + '.js');
     const withTsExtension = path.join(__dirname, file + '.ts');
+    if (fs.existsSync(withCjsExtension)) {
+        return withCjsExtension;
+    }
     if (fs.existsSync(withJsExtension)) {
         return withJsExtension;
     }

package/lib/lib/local/load-foreman-procfile.d.ts

@@ -1,2 +1 @@
-import parseProcfile from 'parse-procfile';
-export default parseProcfile;
+export declare const loadProc: (procfilePath: string) => any;

package/lib/lib/local/load-foreman-procfile.js

@@ -1,3 +1,7 @@
 // @ts-expect-error - parse-procfile lacks TypeScript definitions
 import parseProcfile from 'parse-procfile';
-export default parseProcfile;
+import fs from 'fs';
+export const loadProc = (procfilePath) => {
+    const content = fs.readFileSync(procfilePath, 'utf8');
+    return parseProcfile(content);
+};

package/lib/lib/local/{run-foreman.js → run-foreman.cjs}

@@ -1,7 +1,9 @@
+"use strict";
 // Copyright IBM Corp. 2012,2015. All Rights Reserved.
 // Node module: foreman
 // This file is licensed under the MIT License.
 // License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
 // This file is copied from the Node Foreman package. It was copied in order to fix
 // a bug related to the use of port 5000 as a default. It is not meant to be a
 // long-term solution, we plan to eventually remove our dependency on Node Foreman.
@@ -232,4 +234,3 @@ if (process.argv.slice(2).length === 0) {
     program.outputHelp();
     process.exit(1);
 }
-export {};

package/lib/lib/members/team-invite-utils.d.ts

@@ -0,0 +1,14 @@
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+/**
+ * Standard role description for consistent usage across commands
+ */
+export declare const ROLE_DESCRIPTION = "member role (admin, collaborator, member, owner)";
+/**
+ * Check if team invite acceptance feature is enabled for a team
+ */
+export declare function isTeamInviteFeatureEnabled(team: string, heroku: APIClient): Promise<boolean>;
+/**
+ * Get team invitations with proper headers
+ */
+export declare function getTeamInvites(team: string, heroku: APIClient): Promise<Heroku.TeamInvitation[]>;

package/lib/lib/members/team-invite-utils.js

@@ -0,0 +1,26 @@
+/**
+ * Standard role description for consistent usage across commands
+ */
+export const ROLE_DESCRIPTION = 'member role (admin, collaborator, member, owner)';
+/**
+ * Check if team invite acceptance feature is enabled for a team
+ */
+export async function isTeamInviteFeatureEnabled(team, heroku) {
+    const { body: teamInfo } = await heroku.get(`/teams/${team}`);
+    if (teamInfo.type !== 'team') {
+        return false;
+    }
+    const { body: teamFeatures } = await heroku.get(`/teams/${team}/features`);
+    return teamFeatures.some(feature => feature.name === 'team-invite-acceptance' && feature.enabled);
+}
+/**
+ * Get team invitations with proper headers
+ */
+export async function getTeamInvites(team, heroku) {
+    const { body: teamInvites } = await heroku.get(`/teams/${team}/invitations`, {
+        headers: {
+            Accept: 'application/vnd.heroku+json; version=3.team-invitations',
+        },
+    });
+    return teamInvites;
+}

package/lib/lib/pipelines/disambiguate.js

@@ -1,4 +1,4 @@
-import { prompt } from 'inquirer';
+import inquirer from 'inquirer';
 import { uuidValidate } from '../utils/uuid-validate.js';
 import { findPipelineByName, getPipeline, } from '../api.js';
 export default async function disambiguate(heroku, pipelineIDOrName) {
@@ -31,7 +31,7 @@ export default async function disambiguate(heroku, pipelineIDOrName) {
                 }];
             // eslint-disable-next-line no-async-promise-executor
             pipeline = await new Promise(async function (resolve, reject) {
-                const answers = await prompt(questions);
+                const answers = await inquirer.prompt(questions);
                 if (answers.pipeline) {
                     resolve(answers.pipeline);
                 }

package/lib/lib/pipelines/ownership.d.ts

@@ -1 +1,5 @@
-export {};
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+import { AppWithPipelineCoupling } from '../api.js';
+export declare function warnMixedOwnership(pipelineApps: Array<AppWithPipelineCoupling>, pipeline: Heroku.Pipeline, owner: string): void;
+export declare function getOwner(heroku: APIClient, apps: Array<AppWithPipelineCoupling>, pipeline: Heroku.Pipeline): Promise<any>;

package/lib/lib/pipelines/ownership.js

@@ -1,46 +1,35 @@
-export {};
-/*
-import color from '@heroku-cli/color'
-import {APIClient} from '@heroku-cli/command'
-import * as Heroku from '@heroku-cli/schema'
-import {ux} from '@oclif/core'
-
-import {AppWithPipelineCoupling, getTeam} from '../api'
-
-export function warnMixedOwnership(pipelineApps: Array<AppWithPipelineCoupling>, pipeline: Heroku.Pipeline, owner: string) {
-  const hasMixedOwnership = pipelineApps.some(app => {
-    return (app.owner && app.owner.id) !== pipeline.owner.id
-  })
-
-  if (hasMixedOwnership) {
-    ux.log()
-    let message = `Some apps in this pipeline do not belong to ${color.cmd(owner)}.`
-    message += '\n\nAll apps in a pipeline must have the same owner as the pipeline owner.'
-    message += '\nTransfer these apps or change the pipeline owner in pipeline settings.'
-    message += `\nSee ${color.cyan('https://devcenter.heroku.com/articles/pipeline-ownership-transition')} for more info.`
-    ux.warn(message)
-  }
+import { color } from '@heroku-cli/color';
+import { ux } from '@oclif/core';
+import { getTeam } from '../api.js';
+export function warnMixedOwnership(pipelineApps, pipeline, owner) {
+    const hasMixedOwnership = pipelineApps.some(app => {
+        return (app.owner && app.owner.id) !== pipeline.owner.id;
+    });
+    if (hasMixedOwnership) {
+        ux.stdout();
+        let message = `Some apps in this pipeline do not belong to ${color.cmd(owner)}.`;
+        message += '\n\nAll apps in a pipeline must have the same owner as the pipeline owner.';
+        message += '\nTransfer these apps or change the pipeline owner in pipeline settings.';
+        message += `\nSee ${color.cyan('https://devcenter.heroku.com/articles/pipeline-ownership-transition')} for more info.`;
+        ux.warn(message);
+    }
 }
-
-export function getOwner(heroku: APIClient, apps: Array<AppWithPipelineCoupling>, pipeline: Heroku.Pipeline) {
-  let owner
-  let ownerPromise
-
-  if (pipeline.owner.type === 'team') {
-    ownerPromise = getTeam(heroku, pipeline.owner.id).then(response => response.body)
-  } else {
-    const app = apps.find(app => {
-      return app.owner ? app.owner.id === pipeline.owner.id : false
-    })
-
-    // If pipeline owner doesn't own any application and type is user (unlikely)
-    // We return the uuid as default
-    owner = app ? app.owner && app.owner.email : pipeline.owner.id
-    ownerPromise = Promise.resolve(owner)
-  }
-
-  return ownerPromise.then(owner => {
-    return owner.name ? `${owner.name} (team)` : owner
-  })
+export function getOwner(heroku, apps, pipeline) {
+    let owner;
+    let ownerPromise;
+    if (pipeline.owner.type === 'team') {
+        ownerPromise = getTeam(heroku, pipeline.owner.id).then(response => response.body);
+    }
+    else {
+        const app = apps.find(app => {
+            return app.owner ? app.owner.id === pipeline.owner.id : false;
+        });
+        // If pipeline owner doesn't own any application and type is user (unlikely)
+        // We return the uuid as default
+        owner = app ? app.owner && app.owner.email : pipeline.owner.id;
+        ownerPromise = Promise.resolve(owner);
+    }
+    return ownerPromise.then(owner => {
+        return owner.name ? `${owner.name} (team)` : owner;
+    });
 }
-*/

package/lib/lib/pipelines/render-pipeline.d.ts

@@ -1 +1,7 @@
-export {};
+import { APIClient } from '@heroku-cli/command';
+import * as Heroku from '@heroku-cli/schema';
+import { AppWithPipelineCoupling } from '../api.js';
+export default function renderPipeline(heroku: APIClient, pipeline: Heroku.Pipeline, pipelineApps: Array<AppWithPipelineCoupling>, { withOwners, showOwnerWarning }?: {
+    withOwners: boolean;
+    showOwnerWarning: boolean;
+}): Promise<void>;