heroku 11.8.1 → 11.9.0-beta.0

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
 
+## [11.9.0-beta.0](https://github.com/heroku/cli/compare/v11.8.1...v11.9.0-beta.0) (2026-08-04)
+
+
+### Features
+
+* add credential manager configuration to the oclif init hook ([#3786](https://github.com/heroku/cli/issues/3786)) ([8f0bb4d](https://github.com/heroku/cli/commit/8f0bb4debe2296ad201efd5730697f93756c1ffd))
+
+
+### Bug Fixes
+
+* autocomplete zsh setup guards compinit to prevent double-init ([#3839](https://github.com/heroku/cli/issues/3839)) ([b3d629c](https://github.com/heroku/cli/commit/b3d629c6f9ddd4ec23249a82b0e556fd7909ab7c)), closes [#1686](https://github.com/heroku/cli/issues/1686)
+* config:get --shell does not double-escape backslashes in single-quoted output ([#3833](https://github.com/heroku/cli/issues/3833)) ([bbf0d22](https://github.com/heroku/cli/commit/bbf0d2262919d8dd58aea7c2ed94daa370c21399)), closes [#1384](https://github.com/heroku/cli/issues/1384)
+* pg:backups:capture -v null guard on undefined logs ([#3832](https://github.com/heroku/cli/issues/3832)) ([3c8a567](https://github.com/heroku/cli/commit/3c8a5678d18cf47657c88a23c056075e47129ad3))
+* pg:backups:download respects HTTPS_PROXY env var ([#3836](https://github.com/heroku/cli/issues/3836)) ([288f302](https://github.com/heroku/cli/commit/288f302eb6e93b8fe0f2c8c130815a845a216571)), closes [#1531](https://github.com/heroku/cli/issues/1531)
+* pg:copy confirmation prompt shows addon name not app name ([#3834](https://github.com/heroku/cli/issues/3834)) ([44c5786](https://github.com/heroku/cli/commit/44c5786449e9764da70c6a122ce34ae08ed14293))
+* pipelines:promote exits non-zero on partial failure ([#3835](https://github.com/heroku/cli/issues/3835)) ([30842f8](https://github.com/heroku/cli/commit/30842f8f42adc208cf87a341ca681a1a3b4a2a4c)), closes [#1600](https://github.com/heroku/cli/issues/1600)
+* remove GitHub org/repo in error messages ([#3808](https://github.com/heroku/cli/issues/3808)) ([1419e2a](https://github.com/heroku/cli/commit/1419e2a20edf567776c69966d3cb60e1d92bf9f4))
+* replace jQuery CDN dependency in addons:open SSO template with vanilla JS ([#3837](https://github.com/heroku/cli/issues/3837)) ([1df4b3d](https://github.com/heroku/cli/commit/1df4b3df198329a145521f676dc5a2ccc514196d)), closes [#1541](https://github.com/heroku/cli/issues/1541)
+* vendor node-foreman and replace util._extend with Object.assign ([#3838](https://github.com/heroku/cli/issues/3838)) ([a0b3316](https://github.com/heroku/cli/commit/a0b33160eb8c3173d5e01474b75a2221773cc503)), closes [#3736](https://github.com/heroku/cli/issues/3736) [#3736](https://github.com/heroku/cli/issues/3736) [#3736](https://github.com/heroku/cli/issues/3736) [#3736](https://github.com/heroku/cli/issues/3736) [#3736](https://github.com/heroku/cli/issues/3736)
+
 ## [11.8.1](https://github.com/heroku/cli/compare/v11.8.0...v11.8.1) (2026-07-08)
 
 

package/dist/commands/addons/open.js

@@ -71,7 +71,7 @@ export default class Open extends Command {
     }
     async writeSudoTemplate(app, addon, sso) {
         const ssoPath = path.join(os.tmpdir(), 'heroku-sso.html');
-        const html = `<!DOCTYPE HTML>\n<html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <title>Heroku Add-ons SSO</title>\n    <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min.js"></script>\n  </head>\n\n  <body>\n    <h3>Opening ${addon}${app ? ` on ${app}` : ''}...</h3>\n    <form method="POST" action="${sso.action}">\n    </form>\n\n    <script>\n      var params = ${JSON.stringify(sso.params)}\n      var form = document.forms[0]\n      $(document).ready(function() {\n        $.each(params, function(key, value) {\n          $('<input>').attr({ type: 'hidden', name: key, value: value })\n            .appendTo(form)\n        })\n        form.submit()\n      })\n    </script>\n  </body>\n</html>`;
+        const html = `<!DOCTYPE HTML>\n<html lang="en">\n  <head>\n    <meta charset="utf-8">\n    <title>Heroku Add-ons SSO</title>\n  </head>\n\n  <body>\n    <h3>Opening ${addon}${app ? ` on ${app}` : ''}...</h3>\n    <form method="POST" action="${sso.action}">\n    </form>\n\n    <script>\n      document.addEventListener('DOMContentLoaded', function() {\n        var params = ${JSON.stringify(sso.params)}\n        var form = document.forms[0]\n        Object.keys(params).forEach(function(key) {\n          var input = document.createElement('input')\n          input.type = 'hidden'\n          input.name = key\n          input.value = params[key]\n          form.appendChild(input)\n        })\n        form.submit()\n      })\n    </script>\n  </body>\n</html>`;
         await fs.writeFile(ssoPath, html);
         return ssoPath;
     }

package/dist/commands/autocomplete/create.js

@@ -134,7 +134,7 @@ ${AC_LIB_PATH}/zsh
 $fpath
 );
 autoload -Uz compinit;
-compinit;
+(( \${+functions[compdef]} )) || compinit;
 `;
     }
     get zshSetupScriptPath() {

package/dist/commands/pg/copy.js

@@ -20,14 +20,16 @@ const getAttachmentInfo = async function (heroku, db, app) {
     const { body: addon } = await heroku.get(`/addons/${attachment.addon.name}`);
     const { body: config } = await heroku.get(`/apps/${attachment.app.name}/config-vars`);
     const formattedConfig = Object.fromEntries(Object.entries(config).map(([k, v]) => [k.toUpperCase(), v]));
+    const addonName = attachment.name
+        .replace(/^HEROKU_POSTGRESQL_/, '')
+        .replace(/_URL$/, '');
     return {
         attachment: {
             ...attachment,
             addon,
         },
-        confirm: app,
-        name: attachment.name.replace(/^HEROKU_POSTGRESQL_/, '')
-            .replace(/_URL$/, ''),
+        confirm: addonName,
+        name: addonName,
         url: formattedConfig[attachment.name.toUpperCase() + '_URL'],
     };
 };

package/dist/commands/pipelines/promote.js

@@ -93,6 +93,7 @@ export default class Promote extends Command {
         }
         else {
             ux.warn('\nPromotion to some apps failed');
+            process.exitCode = 1;
         }
         hux.styledObject(styledTargets);
     }

package/dist/hooks/init/configure-git-credential-manager.d.ts

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

package/dist/hooks/init/configure-git-credential-manager.js

@@ -0,0 +1,38 @@
+import Git from '../../lib/git/git.js';
+const hook = async function () {
+    // Skip for --version / --help / completion-style invocations to avoid a needless git subprocess.
+    // Version-style invocations include `--version` plus any `oclif.additionalVersionFlags`
+    // (e.g. `-v`, `version`) declared in package.json — mirror version.ts, which reads the
+    // same config. We hard-include `-v`/`version` as a defensive fallback so this skip can
+    // never silently regress if config is somehow unavailable at runtime.
+    // Help-style invocations are skipped for the same reason: they're fast informational
+    // commands that shouldn't touch git. They include `--help` plus any
+    // `oclif.additionalHelpFlags` (e.g. `-h`) declared in package.json, and we hard-include
+    // `--help`/`-h`/`help` as the same kind of defensive fallback.
+    // Completion invocations are matched by the `autocomplete` prefix, since shell completion
+    // actually runs `autocomplete:options` (not the bare `autocomplete` command).
+    // NOTE: temporary hook until v12.
+    const arg = process.argv[2];
+    const additionalVersionFlags = this.config?.pjson?.oclif?.additionalVersionFlags ?? [];
+    const additionalHelpFlags = this.config?.pjson?.oclif?.additionalHelpFlags ?? [];
+    const skip = new Set([
+        '--help',
+        '--version',
+        '-h',
+        '-v',
+        'help',
+        'version',
+        ...additionalHelpFlags,
+        ...additionalVersionFlags,
+    ]);
+    if (!arg || skip.has(arg) || arg.startsWith('autocomplete'))
+        return;
+    const git = new Git();
+    try {
+        await git.configureCredentialHelper();
+    }
+    catch {
+        // ignore — best-effort; never block a command on git config
+    }
+};
+export default hook;

package/dist/lib/config/quote.js

@@ -9,7 +9,7 @@ export function quote(s) {
                     .replaceAll(/(["\\$`!])/g, String.raw `\$1`)
                     .replaceAll('\n', String.raw `\n`)
                 + '"';
-        return "'" + s.replaceAll(/(['\\])/g, String.raw `\$1`) + "'";
+        return "'" + s + "'";
     }
     return s;
 }
@@ -18,7 +18,7 @@ export function parse(a) {
         a = a.replaceAll(String.raw `\n`, '\n');
     }
     else if (a.startsWith("'")) {
-        a = a.replaceAll('\\\\', '\\');
+        // single-quoted strings are literal in POSIX sh — no unescaping needed
     }
     const parsed = shell.parse(a);
     if (parsed.length > 1)

package/dist/lib/git/git.js

@@ -13,12 +13,18 @@ export default class Git {
     */
     async configureCredentialHelper() {
         const { httpGitHost } = vars;
-        await this.exec([
-            'config',
-            '--global',
-            `credential.https://${httpGitHost}.helper`,
-            '!heroku git:credentials',
-        ]);
+        const key = `credential.https://${httpGitHost}.helper`;
+        const helper = '!heroku git:credentials';
+        // Read the existing value first so we can skip the write when it is already
+        // set to our helper. `git config` rewrites the global config file (new inode)
+        // even when the value is byte-identical, and this runs before nearly every
+        // command via the init hook, so the no-op write churns the user's gitconfig.
+        // When the key is absent the `--get` exits non-zero and `exec` throws, so we
+        // treat that as an empty string.
+        const existing = await this.exec(['config', '--global', '--get', key]).catch(() => '');
+        if (existing === helper)
+            return;
+        await this.exec(['config', '--global', key, helper]);
     }
     createRemote(remote, url) {
         return this.hasGitRemote(remote)

package/dist/lib/local/foreman/colors.cjs

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright IBM Corp. 2012,2016. All Rights Reserved.
+// Node module: foreman
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+var reset = '\x1B[0m';
+var colors = {
+    magenta: '\x1B[35m',
+    blue: '\x1B[34m',
+    cyan: '\x1B[36m',
+    green: '\x1B[32m',
+    yellow: '\x1B[33m',
+    red: '\x1B[31m',
+    bright_magenta: '\x1B[35m',
+    bright_cyan: '\x1B[36m',
+    bright_blue: '\x1B[34m',
+    bright_green: '\x1B[32m',
+    bright_yellow: '\x1B[33m',
+    bright_red: '\x1B[31m',
+};
+function identity(self) {
+    return self;
+}
+function colorizer(color) {
+    if (process.stdout.isTTY) {
+        return function (str) {
+            return colors[color] + str + reset;
+        };
+    }
+    else {
+        return identity;
+    }
+}
+module.exports.colors = [];
+var colorKeys = Object.keys(colors);
+colorKeys.forEach(function (name) {
+    var colorFn = colorizer(name);
+    module.exports[name] = colorFn;
+    module.exports.colors.push(colorFn);
+});
+module.exports.colors_max = module.exports.colors.length;

package/dist/lib/local/foreman/colors.d.cts

@@ -0,0 +1,2 @@
+export const colors: any[];
+export { length as colors_max };

package/dist/lib/local/foreman/console.cjs

@@ -0,0 +1,103 @@
+"use strict";
+// Copyright IBM Corp. 2012,2016. All Rights Reserved.
+// Node module: foreman
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+var util = require('util');
+var colors = require('./colors.cjs');
+function wrap(log, length, res) {
+    if (!res) {
+        res = [];
+    }
+    if (log.length <= length) {
+        res.push(log);
+        return res;
+    }
+    else {
+        res.push(log.substr(0, length));
+        return wrap(log.substr(length), length, res);
+    }
+}
+var trimEnd = '\u2026';
+var ansiEscapes = /\x1b\[(\d+([A-GJKSTm]|;\d+[Hf])|6n|s|u|\?25[lh])/g;
+function stripANSI(str) {
+    return str.replace(ansiEscapes, '');
+}
+function trim(line, n) {
+    line = line.replace(/\s+$/, '');
+    var stripped = stripANSI(line);
+    if (stripped.length <= n) {
+        return line;
+    }
+    else {
+        return stripped.substr(0, n) + trimEnd;
+    }
+}
+function Console(logger) {
+    logger = logger || console;
+    this.padding = 25;
+    this.trimline = 10;
+    this.wrapline = 500;
+    this.fmt = function fmt() {
+        return util.format.apply(null, arguments);
+    };
+    this.pad = function pad(string, n) {
+        var l = string.length;
+        var o = string;
+        for (var i = l; i < n; i++) {
+            o += " ";
+        }
+        return o;
+    };
+    this.trim = trim;
+    this.info = function info(key, proc, string) {
+        var stamp = (new Date().toLocaleTimeString()) + " " + key;
+        logger.log(proc.color(this.pad(stamp, this.padding)), colors.cyan(string));
+    };
+    this.error = function error(key, proc, string) {
+        var stamp = (new Date().toLocaleTimeString()) + " " + key;
+        logger.error(proc.color(this.pad(stamp, this.padding)), colors.red(string));
+    };
+    this.log = function log(key, proc, string) {
+        var self = this;
+        if (self.raw) {
+            logger.log(string);
+            return;
+        }
+        string.split(/\n/).forEach(function (line) {
+            if (line.trim().length === 0) {
+                return;
+            }
+            var stamp = (new Date().toLocaleTimeString()) + " " + key;
+            if (self.trimline > 0) {
+                line = self.trim(line, self.trimline);
+            }
+            var delimiter = " | ";
+            var wrapline;
+            if (self.wrapline === 0) {
+                wrapline = line.length;
+            }
+            else {
+                wrapline = self.wrapline;
+            }
+            wrap(line, wrapline).forEach(function (l) {
+                logger.log(proc.color(self.pad(stamp, self.padding) + delimiter), l);
+                delimiter = " | > ";
+            });
+        });
+    };
+    this.Alert = function Alert() {
+        logger.log(colors.green('[OKAY] ' + this.fmt.apply(null, arguments)));
+    };
+    this.Done = function Info() {
+        logger.log(colors.cyan('[DONE] ' + this.fmt.apply(null, arguments)));
+    };
+    this.Warn = function Warn() {
+        logger.warn(colors.yellow('[WARN] ' + this.fmt.apply(null, arguments)));
+    };
+    this.Error = function Error() {
+        logger.error(colors.bright_red('[FAIL] ' + this.fmt.apply(null, arguments)));
+    };
+}
+module.exports = Console;
+Console.Console = new Console();

package/dist/lib/local/foreman/console.d.cts

@@ -0,0 +1,22 @@
+export = Console;
+declare function Console(logger: any): void;
+declare class Console {
+    constructor(logger: any);
+    padding: number;
+    trimline: number;
+    wrapline: number;
+    fmt: (...args: any[]) => string;
+    pad: (string: any, n: any) => any;
+    trim: typeof trim;
+    info: (key: any, proc: any, string: any) => void;
+    error: (key: any, proc: any, string: any) => void;
+    log: (key: any, proc: any, string: any) => void;
+    Alert: (...args: any[]) => void;
+    Done: (...args: any[]) => void;
+    Warn: (...args: any[]) => void;
+    Error: (...args: any[]) => void;
+}
+declare namespace Console {
+    let Console: Console;
+}
+declare function trim(line: any, n: any): any;

package/dist/lib/local/foreman/envs.cjs

@@ -0,0 +1,103 @@
+"use strict";
+// Copyright IBM Corp. 2012,2016. All Rights Reserved.
+// Node module: foreman
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+var fs = require('fs');
+var cons = require('./console.cjs').Console;
+function method(name) {
+    return function (o) {
+        return o[name].apply(o);
+    };
+}
+// Parse a Key=Value File Containing Environmental Variables
+function keyValue(data) {
+    var env = {};
+    data
+        .toString()
+        .replace(/^\s*\#.*$/gm, '')
+        .replace(/^\s*$/gm, '')
+        .split(/\n/)
+        .map(method('trim'))
+        .filter(notBlank)
+        .forEach(capturePair);
+    return env;
+    function notBlank(str) {
+        return str.length > 2;
+    }
+    function capturePair(line) {
+        var pair = line.split('=');
+        var key = pair[0].trim();
+        var rawVal = pair.slice(1).join('=').trim();
+        env[key] = parseValue(rawVal);
+    }
+    function parseValue(val) {
+        switch (val[0]) {
+            case '"': return /^"([^"]*)"/.exec(val)[1];
+            case "'": return /^'([^']*)'/.exec(val)[1];
+            default: return val.replace(/\s*\#.*$/, '');
+        }
+    }
+}
+// Flatten nested object structure into KEY_SUBKEY=value pairs
+function flattenJSON(json) {
+    var flattened = {};
+    walk(json, function (path, item) {
+        flattened[path.join('_').toUpperCase()] = item;
+    });
+    return flattened;
+    function walk(obj, visitor, path) {
+        var item;
+        path = path || [];
+        for (var key in obj) {
+            item = obj[key];
+            if (typeof item === 'object') {
+                walk(item, visitor, path.concat(key));
+            }
+            else {
+                visitor(path.concat(key), item);
+            }
+        }
+    }
+}
+function dumpEnv(conf) {
+    var output = [];
+    for (var key in conf) {
+        output.push(key + '=' + conf[key]);
+    }
+    return output.sort().join('\n') + '\n';
+}
+function loadEnvsFile(path) {
+    var env, data;
+    if (!fs.existsSync(path)) {
+        env = {};
+    }
+    else {
+        data = fs.readFileSync(path);
+        try {
+            var envs_json = JSON.parse(data);
+            env = flattenJSON(envs_json, "", {});
+            cons.Alert("Loaded ENV %s File as JSON Format", path);
+        }
+        catch (e) {
+            env = keyValue(data);
+            cons.Alert("Loaded ENV %s File as KEY=VALUE Format", path);
+        }
+    }
+    env.PATH = env.PATH || process.env.PATH;
+    return env;
+}
+function loadEnvs(path) {
+    var envs = path.split(',').map(loadEnvsFile).reduce(function (acc, obj) {
+        return Object.assign(acc, obj);
+    }, {});
+    var sorted = Object.create(null);
+    Object.keys(envs).sort().forEach(function (k) {
+        sorted[k] = envs[k];
+    });
+    return sorted;
+}
+module.exports.loadEnvs = loadEnvs;
+module.exports.flattenJSON = flattenJSON;
+module.exports.keyValue = keyValue;
+module.exports.dumpEnv = dumpEnv;

package/dist/lib/local/foreman/envs.d.cts

@@ -0,0 +1,4 @@
+export function loadEnvs(path: any): any;
+export function flattenJSON(json: any): {};
+export function keyValue(data: any): {};
+export function dumpEnv(conf: any): string;

package/dist/lib/local/foreman/forward.cjs

@@ -0,0 +1,27 @@
+"use strict";
+// Copyright IBM Corp. 2012,2016. All Rights Reserved.
+// Node module: foreman
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+var prog = require('child_process');
+var cons = require('./console.cjs').Console;
+function startForward(port, hostname, emitter) {
+    var proc = prog.fork(__dirname + '/../forward.js', [], {
+        env: {
+            PROXY_PORT: port,
+            PROXY_HOST: hostname || ' '
+        }
+    });
+    cons.Alert('Forward Proxy Started in Port %d', port);
+    if (hostname) {
+        cons.Alert('Intercepting requests to %s through forward proxy', hostname);
+    }
+    else {
+        cons.Alert('Intercepting ALL requests through forward proxy');
+    }
+    emitter.once('killall', function (signal) {
+        cons.Done('Killing Forward Proxy Server on Port %d', port);
+        proc.kill(signal);
+    });
+}
+module.exports.startForward = startForward;

package/dist/lib/local/foreman/forward.d.cts

@@ -0,0 +1 @@
+export function startForward(port: any, hostname: any, emitter: any): void;

package/dist/lib/local/foreman/proc.cjs

@@ -0,0 +1,115 @@
+"use strict";
+// Copyright IBM Corp. 2012,2016. All Rights Reserved.
+// Node module: foreman
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+var prog = require('child_process');
+var cons = require('./console.cjs').Console;
+var _colors = require('./colors.cjs');
+var colors_max = _colors.colors_max;
+var colors = _colors.colors;
+var os = require('os');
+var platform = os.platform();
+function run(key, proc, emitter) {
+    var file, args;
+    if (platform === 'win32') {
+        file = process.env.comspec || 'cmd.exe';
+        args = ['/s', '/c', proc.command];
+    }
+    else {
+        file = '/bin/sh';
+        args = ['-c', proc.command];
+    }
+    var child = prog.spawn(file, args, { env: proc.env });
+    var killallReceived = false;
+    child.stdout.on('data', function (data) {
+        cons.log(key, proc, data.toString());
+    });
+    child.stderr.on('data', function (data) {
+        cons.log(key, proc, data.toString());
+    });
+    child.on('close', function (code, signal) {
+        if (code === 0) {
+            cons.info(key, proc, "Exited Successfully");
+        }
+        else {
+            cons.error(key, proc, "Exited with exit code " + signal || code);
+        }
+    });
+    child.on('exit', function (code, signal) {
+        if (!killallReceived) {
+            emitter.emit('killall', signal || 'SIGINT');
+        }
+    });
+    emitter.on('killall', function (signal) {
+        killallReceived = true;
+        try {
+            child.kill(signal);
+        }
+        catch (err) {
+            if (err.code === 'EPERM') {
+                cons.error(key, proc, "Process has become unkillable; returns EPERM.");
+            }
+        }
+    });
+}
+function once(input, envs, callback) {
+    var file, args;
+    var proc = {
+        command: input,
+        env: merge(merge({}, process.env), envs)
+    };
+    if (platform === 'win32') {
+        file = process.env.comspec || 'cmd.exe';
+        args = ['/s', '/c', proc.command];
+    }
+    else {
+        file = '/bin/sh';
+        args = ['-c', proc.command];
+    }
+    var child = prog.spawn(file, args, { env: proc.env, stdio: 'inherit' });
+    child.on('close', function (code) {
+        callback(code);
+    });
+}
+function start(procs, requirements, envs, portarg, emitter) {
+    var j = 0;
+    var k = 0;
+    var port = parseInt(portarg);
+    if (port < 1024) {
+        return cons.Error('Only Proxies Can Bind to Privileged Ports - ' +
+            'Try \'sudo nf start -x %s\'', port);
+    }
+    for (var key in requirements) {
+        var n = parseInt(requirements[key]);
+        for (var i = 0; i < n; i++) {
+            var color_val = (j + k) % colors_max;
+            if (!procs[key]) {
+                cons.Warn("Required Key '%s' Does Not Exist in Procfile Definition", key);
+                continue;
+            }
+            var p = {
+                command: procs[key],
+                color: colors[color_val],
+                env: merge(merge({}, process.env), envs)
+            };
+            p.env.PORT = port + j + k * 100;
+            p.env.FOREMAN_WORKER_NAME = p.env.FOREMAN_WORKER_NAME || key + "." + (i + 1);
+            run(key + "." + (i + 1), p, emitter);
+            j++;
+        }
+        j = 0;
+        k++;
+    }
+}
+function merge(a, b) {
+    if (a && b) {
+        for (var key in b) {
+            a[key] = b[key];
+        }
+    }
+    return a;
+}
+module.exports.start = start;
+module.exports.run = run;
+module.exports.once = once;

package/dist/lib/local/foreman/proc.d.cts

@@ -0,0 +1,3 @@
+export function start(procs: any, requirements: any, envs: any, portarg: any, emitter: any): void;
+export function run(key: any, proc: any, emitter: any): void;
+export function once(input: any, envs: any, callback: any): void;

package/dist/lib/local/foreman/procfile.cjs

@@ -0,0 +1,46 @@
+"use strict";
+// Copyright IBM Corp. 2012,2016. All Rights Reserved.
+// Node module: foreman
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+var fs = require('fs');
+var cons = require('./console.cjs').Console;
+var path = require('path');
+function procs(procdata) {
+    var processes = {};
+    procdata.toString().split(/\n/).forEach(function (line) {
+        if (!line || line[0] === '#') {
+            return;
+        }
+        var tuple = /^([A-Za-z0-9_-]+):\s*(.+)$/m.exec(line);
+        var prockey = tuple[1].trim();
+        var command = tuple[2].trim();
+        if (!prockey) {
+            throw new Error('Syntax Error in Procfile, Line %d: No Prockey Found');
+        }
+        if (!command) {
+            throw new Error('Syntax Error in Procfile, Line %d: No Command Found');
+        }
+        processes[prockey] = command;
+    });
+    return processes;
+}
+function loadProc(filename) {
+    try {
+        var data = fs.readFileSync(filename);
+        return procs(data);
+    }
+    catch (e) {
+        cons.Warn(e.message);
+        if (fs.existsSync('package.json')) {
+            cons.Alert("package.json file found - trying 'npm start'");
+            return procs("web: npm start");
+        }
+        else {
+            cons.Error("No Procfile and no package.json file found in Current Directory - See " + path.basename(process.argv[1]) + " --help");
+            return;
+        }
+    }
+}
+module.exports.loadProc = loadProc;
+module.exports.procs = procs;

package/dist/lib/local/foreman/procfile.d.cts

@@ -0,0 +1,2 @@
+export function loadProc(filename: any): {} | undefined;
+export function procs(procdata: any): {};