@depup/oclif 4.22.92-depup.1

package/lib/commands/manifest.js

@@ -0,0 +1,156 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const fs_extra_1 = require("fs-extra");
+const node_child_process_1 = require("node:child_process");
+const os = __importStar(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+async function fileExists(filePath) {
+    try {
+        await (0, fs_extra_1.access)(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+class Manifest extends core_1.Command {
+    static args = {
+        path: core_1.Args.string({ default: '.', description: 'Path to plugin.' }),
+    };
+    static description = 'Generates plugin manifest json (oclif.manifest.json).';
+    static flags = {
+        jit: core_1.Flags.boolean({
+            allowNo: true,
+            default: true,
+            summary: 'Append commands from JIT plugins in manifest.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Manifest);
+        try {
+            (0, fs_extra_1.unlinkSync)('oclif.manifest.json');
+        }
+        catch { }
+        const { args } = await this.parse(Manifest);
+        const root = node_path_1.default.resolve(args.path);
+        const packageJson = (0, fs_extra_1.readJSONSync)(node_path_1.default.join(root, 'package.json'));
+        let jitPluginManifests = [];
+        if (flags.jit && packageJson.oclif?.jitPlugins) {
+            this.debug('jitPlugins: %s', packageJson.oclif.jitPlugins);
+            const tmpDir = os.tmpdir();
+            const promises = Object.entries(packageJson.oclif.jitPlugins).map(async ([jitPlugin, version]) => {
+                const pluginDir = jitPlugin.replace('/', '-').replace('@', '');
+                const fullPath = node_path_1.default.join(tmpDir, pluginDir);
+                if (await fileExists(fullPath))
+                    await (0, fs_extra_1.remove)(fullPath);
+                await (0, fs_extra_1.mkdir)(fullPath, { recursive: true });
+                const tarball = await this.downloadTarball(jitPlugin, version, fullPath);
+                await this.executeCommand(`tar -xzf "${tarball}"`, { cwd: fullPath });
+                const manifest = (await (0, fs_extra_1.readJSON)(node_path_1.default.join(fullPath, 'package', 'oclif.manifest.json')));
+                for (const command of Object.values(manifest.commands)) {
+                    command.pluginType = 'jit';
+                }
+                return manifest;
+            });
+            core_1.ux.action.start('Generating JIT plugin manifests');
+            jitPluginManifests = await Promise.all(promises);
+            core_1.ux.action.stop();
+        }
+        let plugin = new core_1.Plugin({
+            errorOnManifestCreate: true,
+            ignoreManifest: true,
+            respectNoCacheDefault: true,
+            root,
+            type: 'core',
+        });
+        if (!plugin)
+            throw new Error('plugin not found');
+        await plugin.load();
+        if (!plugin.valid) {
+            const { PluginLegacy } = await import('@oclif/plugin-legacy');
+            // @ts-expect-error for now because PluginLegacy doesn't use the same major of @oclif/core
+            plugin = new PluginLegacy(this.config, plugin);
+            await plugin.load();
+        }
+        if (!Array.isArray(plugin.pjson.files)) {
+            this.error('The package.json has to contain a "files" array', {
+                ref: 'https://docs.npmjs.com/cli/v10/configuring-npm/package-json#files',
+                suggestions: [
+                    'Add a "files" property in the package.json listing the paths to the files that should be included in the published package',
+                ],
+            });
+        }
+        const dotfile = plugin.pjson.files.find((f) => f.endsWith('.oclif.manifest.json'));
+        const file = node_path_1.default.join(plugin.root, `${dotfile ? '.' : ''}oclif.manifest.json`);
+        for (const manifest of jitPluginManifests) {
+            plugin.manifest.commands = { ...plugin.manifest.commands, ...manifest.commands };
+        }
+        (0, fs_extra_1.writeFileSync)(file, JSON.stringify(plugin.manifest, null, 2));
+        this.log(`wrote manifest to ${file}`);
+        return plugin.manifest;
+    }
+    async downloadTarball(plugin, version, tarballStoragePath) {
+        const { stderr } = await this.executeCommand(`npm pack ${plugin}@${version} --pack-destination "${tarballStoragePath}" --json`);
+        // You can `npm pack` with multiple modules to download multiple at a time. There will be at least 1 if the command
+        // succeeded.
+        const tarballs = JSON.parse(stderr);
+        if (!Array.isArray(tarballs) || tarballs.length !== 1) {
+            throw new Error(`Could not download tarballs for ${plugin}. Tarball download was not in the correct format.`);
+        }
+        const { filename } = tarballs[0];
+        return node_path_1.default.join(tarballStoragePath, filename);
+    }
+    async executeCommand(command, options) {
+        return new Promise((resolve) => {
+            (0, node_child_process_1.exec)(command, options, (error, stderr, stdout) => {
+                if (error)
+                    this.error(error);
+                const debugString = options?.cwd
+                    ? `executing command: ${command} in ${options.cwd}`
+                    : `executing command: ${command}`;
+                this.debug(debugString);
+                this.debug(stdout);
+                this.debug(stderr);
+                resolve({ stderr: stderr.toString(), stdout: stdout.toString() });
+            });
+        });
+    }
+}
+exports.default = Manifest;

package/lib/commands/pack/deb.d.ts

@@ -0,0 +1,13 @@
+import { Command, Interfaces } from '@oclif/core';
+export default class PackDeb extends Command {
+    static description: string;
+    static flags: {
+        compression: Interfaces.OptionFlag<"xz" | "none" | "gzip" | "zstd" | undefined, Interfaces.CustomOptions>;
+        'prune-lockfiles': Interfaces.BooleanFlag<boolean>;
+        root: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        sha: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        tarball: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+}

package/lib/commands/pack/deb.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const fs = __importStar(require("fs-extra"));
+const node_child_process_1 = require("node:child_process");
+const fsPromises = __importStar(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const semver_1 = require("semver");
+const Tarballs = __importStar(require("../../tarballs"));
+const upload_util_1 = require("../../upload-util");
+const util_1 = require("../../util");
+const exec = (0, node_util_1.promisify)(node_child_process_1.exec);
+const scripts = {
+    /* eslint-disable no-useless-escape */
+    bin: (config) => `#!/usr/bin/env bash
+set -e
+echoerr() { echo "$@" 1>&2; }
+get_script_dir () {
+  SOURCE="\${BASH_SOURCE[0]}"
+  # While \$SOURCE is a symlink, resolve it
+  while [ -h "\$SOURCE" ]; do
+    DIR="\$( cd -P "\$( dirname "\$SOURCE" )" && pwd )"
+    SOURCE="\$( readlink "\$SOURCE" )"
+    # If \$SOURCE was a relative symlink (so no "/" as prefix, need to resolve it relative to the symlink base directory
+    [[ \$SOURCE != /* ]] && SOURCE="\$DIR/\$SOURCE"
+  done
+  DIR="\$( cd -P "\$( dirname "\$SOURCE" )" && pwd )"
+  echo "\$DIR"
+}
+DIR=\$(get_script_dir)
+export ${config.scopedEnvVarKey('UPDATE_INSTRUCTIONS')}="update with \\"sudo apt update && sudo apt install ${config.bin}\\""
+\$DIR/node \$DIR/run "\$@"
+`,
+    /* eslint-enable no-useless-escape */
+    control: (config, arch) => `Package: ${config.config.bin}
+Version: ${(0, upload_util_1.debVersion)(config)}
+Section: main
+Priority: standard
+Architecture: ${arch}
+Maintainer: ${config.config.scopedEnvVar('AUTHOR') || config.config.pjson.author}
+Description: ${config.config.pjson.description}
+Aliases: ${config.config.binAliases?.join(', ')}
+`,
+    ftparchive: (config) => `
+APT::FTPArchive::Release {
+  Origin "${config.scopedEnvVar('AUTHOR') || config.pjson.author}";
+  Suite  "stable";
+`,
+};
+class PackDeb extends core_1.Command {
+    static description = 'Add a pretarball script to your package.json if you need to run any scripts before the tarball is created.';
+    static flags = {
+        compression: core_1.Flags.option({
+            options: ['gzip', 'none', 'xz', 'zstd'],
+        })({
+            char: 'z',
+            description: 'For more details see the `-Zcompress-type` section at https://man7.org/linux/man-pages/man1/dpkg-deb.1.html',
+            summary: 'Override the default compression used by dpkg-deb.',
+        }),
+        'prune-lockfiles': core_1.Flags.boolean({ description: 'remove lockfiles in the tarball.', exclusive: ['tarball'] }),
+        root: core_1.Flags.string({ char: 'r', default: '.', description: 'Path to oclif CLI root.', required: true }),
+        sha: core_1.Flags.string({
+            description: '7-digit short git commit SHA (defaults to current checked out commit).',
+            required: false,
+        }),
+        tarball: core_1.Flags.string({
+            char: 't',
+            description: 'Optionally specify a path to a tarball already generated by NPM.',
+            exclusive: ['prune-lockfiles'],
+            required: false,
+        }),
+    };
+    static summary = 'Pack CLI into debian package.';
+    async run() {
+        if (process.platform !== 'linux')
+            throw new Error('debian packing must be run on linux');
+        const { flags } = await this.parse(PackDeb);
+        const buildConfig = await Tarballs.buildConfig(flags.root, { sha: flags?.sha });
+        const { config } = buildConfig;
+        await Tarballs.build(buildConfig, {
+            pack: false,
+            parallel: true,
+            platform: 'linux',
+            pruneLockfiles: flags['prune-lockfiles'],
+            tarball: flags.tarball,
+        });
+        const dist = buildConfig.dist('deb');
+        await fs.emptyDir(dist);
+        const build = async (arch) => {
+            this.log(`building debian / ${arch}`);
+            const target = { arch, platform: 'linux' };
+            const versionedDebBase = (0, upload_util_1.templateShortKey)('deb', {
+                arch: (0, upload_util_1.debArch)(arch),
+                bin: config.bin,
+                versionShaRevision: (0, upload_util_1.debVersion)(buildConfig),
+            });
+            const workspace = node_path_1.default.join(buildConfig.tmp, 'apt', versionedDebBase.replace('.deb', '.apt'));
+            await fs.remove(workspace);
+            await Promise.all([
+                fsPromises.mkdir(node_path_1.default.join(workspace, 'DEBIAN'), { recursive: true }),
+                fsPromises.mkdir(node_path_1.default.join(workspace, 'usr', 'bin'), { recursive: true }),
+            ]);
+            await fs.copy(buildConfig.workspace(target), node_path_1.default.join(workspace, 'usr', 'lib', config.dirname));
+            await Promise.all([
+                // usr/lib/oclif/bin/oclif (the executable)
+                fsPromises.writeFile(node_path_1.default.join(workspace, 'usr', 'lib', config.dirname, 'bin', config.bin), scripts.bin(config), { mode: 0o755 }),
+                fsPromises.writeFile(node_path_1.default.join(workspace, 'DEBIAN', 'control'), scripts.control(buildConfig, (0, upload_util_1.debArch)(arch))),
+            ]);
+            // symlink usr/bin/oclif points to usr/lib/oclif/bin/oclif
+            await exec(`ln -s "${node_path_1.default.join('..', 'lib', config.dirname, 'bin', config.bin)}" "${config.bin}"`, {
+                cwd: node_path_1.default.join(workspace, 'usr', 'bin'),
+            });
+            config.binAliases?.map((alias) => exec(`ln -sf "${node_path_1.default.join('..', 'lib', config.dirname, 'bin', config.bin)}" "${alias}"`, {
+                cwd: node_path_1.default.join(workspace, 'usr', 'bin'),
+            }));
+            await exec(`sudo chown -R root "${workspace}"`);
+            await exec(`sudo chgrp -R root "${workspace}"`);
+            const dpkgDeb = flags.compression ? `dpkg-deb --build "-Z${flags.compression}"` : 'dpkg-deb --build';
+            await exec(`${dpkgDeb} "${workspace}" "${node_path_1.default.join(dist, versionedDebBase)}"`);
+            this.log(`finished building debian / ${arch}`);
+        };
+        const arches = (0, util_1.uniq)(buildConfig.targets
+            .filter((t) => t.platform === 'linux')
+            .filter((t) => {
+            // Skip 32-bit Arm for Node.js 24+
+            if (t.arch === 'arm' && (0, semver_1.gt)(buildConfig.nodeVersion, '24.0.0')) {
+                return false;
+            }
+            return true;
+        })
+            .map((t) => t.arch));
+        await Promise.all(arches.map((a) => build(a)));
+        await exec('apt-ftparchive packages . > Packages', { cwd: dist });
+        this.log('debian packages created');
+        await Promise.all([
+            exec('gzip -c Packages > Packages.gz', { cwd: dist }),
+            exec('bzip2 -k Packages', { cwd: dist }),
+            exec('xz -k Packages', { cwd: dist }),
+            packForFTP(buildConfig, config, dist),
+        ]);
+        this.log('debian packages archived');
+        const gpgKey = config.scopedEnvVar('DEB_KEY');
+        if (gpgKey) {
+            this.log('adding gpg signatures to Release');
+            await exec(`gpg --digest-algo SHA512 --clearsign -u ${gpgKey} -o InRelease Release`, { cwd: dist });
+            await exec(`gpg --digest-algo SHA512 -abs -u ${gpgKey} -o Release.gpg Release`, { cwd: dist });
+        }
+        this.log('debian packing complete');
+    }
+}
+exports.default = PackDeb;
+async function packForFTP(buildConfig, config, dist) {
+    const ftparchive = node_path_1.default.join(buildConfig.tmp, 'apt', 'apt-ftparchive.conf');
+    await fsPromises.mkdir(node_path_1.default.basename(ftparchive), { recursive: true });
+    await fs.writeFile(ftparchive, scripts.ftparchive(config));
+    await exec(`apt-ftparchive -c "${ftparchive}" release . > Release`, { cwd: dist });
+}

package/lib/commands/pack/macos.d.ts

@@ -0,0 +1,14 @@
+import { Command, Interfaces } from '@oclif/core';
+export default class PackMacos extends Command {
+    static description: string;
+    static flags: {
+        'additional-cli': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        'prune-lockfiles': Interfaces.BooleanFlag<boolean>;
+        root: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        sha: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        tarball: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        targets: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+}

package/lib/commands/pack/macos.js

@@ -0,0 +1,273 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const fs = __importStar(require("fs-extra"));
+const node_child_process_1 = require("node:child_process");
+const os = __importStar(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const Tarballs = __importStar(require("../../tarballs"));
+const upload_util_1 = require("../../upload-util");
+const util_1 = require("../../util");
+const exec = (0, node_util_1.promisify)(node_child_process_1.exec);
+const noBundleConfiguration = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<array/>
+</plist>
+`;
+const scripts = {
+    postinstall: (config, additionalCLI) => `#!/usr/bin/env bash
+set -x
+sudo mkdir -p /usr/local/bin
+sudo ln -sf /usr/local/lib/${config.dirname}/bin/${config.bin} /usr/local/bin/${config.bin}
+${config.binAliases
+        ? config.binAliases
+            ?.map((alias) => `sudo ln -sf /usr/local/lib/${config.dirname}/bin/${config.bin} /usr/local/bin/${alias}`)
+            .join(os.EOL)
+        : ''}
+${additionalCLI
+        ? `sudo ln -sf /usr/local/lib/${config.dirname}/bin/${additionalCLI} /usr/local/bin/${additionalCLI}`
+        : ''}
+`,
+    preinstall: (config, additionalCLI) => `#!/usr/bin/env bash
+sudo rm -rf /usr/local/lib/${config.dirname}
+sudo rm -rf /usr/local/${config.bin}
+sudo rm -rf /usr/local/bin/${config.bin}
+${additionalCLI
+        ? `sudo rm -rf /usr/local/${additionalCLI}
+sudo rm -rf /usr/local/bin/${additionalCLI}`
+        : ''}
+${config.binAliases ? config.binAliases.map((alias) => `sudo rm -rf /usr/local/bin/${alias}`).join(os.EOL) : ''}
+`,
+    uninstall(config, additionalCLI) {
+        const packageIdentifier = config.pjson.oclif.macos.identifier;
+        return `#!/usr/bin/env bash
+
+#Parameters
+DATE=\`date +%Y-%m-%d\`
+TIME=\`date +%H:%M:%S\`
+LOG_PREFIX="[$DATE $TIME]"
+
+#Functions
+log_info() {
+    echo "\${LOG_PREFIX}[INFO]" $1
+}
+
+log_warn() {
+    echo "\${LOG_PREFIX}[WARN]" $1
+}
+
+log_error() {
+    echo "\${LOG_PREFIX}[ERROR]" $1
+}
+
+#Check running user
+if (( $EUID != 0 )); then
+    echo "Please run as root."
+    exit
+fi
+
+echo "Welcome to Application Uninstaller"
+echo "The following packages will be REMOVED:"
+echo "  ${config.dirname}"
+while [ "$1" != "-y" ]; do
+    read -p "Do you wish to continue [Y/n]?" answer
+    [[ $answer == "y" || $answer == "Y" || $answer == "" ]] && break
+    [[ $answer == "n" || $answer == "N" ]] && exit 0
+    echo "Please answer with 'y' or 'n'"
+done
+
+echo "Application uninstalling process started"
+# remove bin aliases link
+${config.binAliases
+            ? config.binAliases.map((alias) => `find "/usr/local/bin/" -name "${alias}" | xargs rm`).join(os.EOL)
+            : ''}
+# remove link to shortcut file
+find "/usr/local/bin/" -name "${config.bin}" | xargs rm
+${additionalCLI ? `find "/usr/local/bin/" -name "${additionalCLI}" | xargs rm` : ''}
+if [ $? -eq 0 ]
+then
+  echo "[1/3] [DONE] Successfully deleted shortcut links"
+else
+  echo "[1/3] [ERROR] Could not delete shortcut links" >&2
+fi
+
+#forget from pkgutil
+pkgutil --forget "${packageIdentifier}" > /dev/null 2>&1
+if [ $? -eq 0 ]
+then
+  echo "[2/3] [DONE] Successfully deleted application information"
+else
+  echo "[2/3] [ERROR] Could not delete application information" >&2
+fi
+
+#remove application source distribution
+[ -e "/usr/local/lib/${config.dirname}" ] && rm -rf "/usr/local/lib/${config.dirname}"
+
+#remove application data directory
+[ -e "${config.dataDir}" ] && rm -rf "${config.dataDir}"
+
+#remove application cache directory
+[ -e "${config.cacheDir}" ] && rm -rf "${config.cacheDir}"
+
+#remove application config directory
+[ -e "${config.configDir}" ] && rm -rf "${config.configDir}"
+
+if [ $? -eq 0 ]
+then
+  echo "[3/3] [DONE] Successfully deleted application"
+else
+  echo "[3/3] [ERROR] Could not delete application" >&2
+fi
+
+echo "Application uninstall process finished"
+exit 0
+`;
+    },
+};
+class PackMacos extends core_1.Command {
+    static description = 'Add a pretarball script to your package.json if you need to run any scripts before the tarball is created.';
+    static flags = {
+        'additional-cli': core_1.Flags.string({
+            description: `An Oclif CLI other than the one listed in config.bin that should be made available to the user
+the CLI should already exist in a directory named after the CLI that is the root of the tarball produced by "oclif pack:tarballs"`,
+            hidden: true,
+        }),
+        'prune-lockfiles': core_1.Flags.boolean({ description: 'remove lockfiles in the tarball.', exclusive: ['tarball'] }),
+        root: core_1.Flags.string({
+            char: 'r',
+            default: '.',
+            description: 'Path to oclif CLI root.',
+            required: true,
+        }),
+        sha: core_1.Flags.string({
+            description: '7-digit short git commit SHA (defaults to current checked out commit).',
+            required: false,
+        }),
+        tarball: core_1.Flags.string({
+            char: 't',
+            description: 'Optionally specify a path to a tarball already generated by NPM.',
+            exclusive: ['prune-lockfiles'],
+            required: false,
+        }),
+        targets: core_1.Flags.string({
+            description: 'Comma-separated targets to pack (e.g.: darwin-x64,darwin-arm64).',
+        }),
+    };
+    static summary = 'Pack CLI into macOS .pkg';
+    async run() {
+        if (process.platform !== 'darwin')
+            this.error('must be run from macos');
+        const { flags } = await this.parse(PackMacos);
+        const buildConfig = await Tarballs.buildConfig(flags.root, { sha: flags?.sha, targets: flags?.targets?.split(',') });
+        const { config } = buildConfig;
+        const c = config.pjson.oclif;
+        if (!c.macos)
+            this.error('package.json is missing an oclif.macos config');
+        if (!c.macos.identifier)
+            this.error('package.json must have oclif.macos.identifier set');
+        const macos = c.macos;
+        const packageIdentifier = macos.identifier;
+        await Tarballs.build(buildConfig, {
+            pack: false,
+            parallel: true,
+            platform: 'darwin',
+            pruneLockfiles: flags['prune-lockfiles'],
+            tarball: flags.tarball,
+        });
+        const scriptsDir = node_path_1.default.join(buildConfig.tmp, 'macos/scripts');
+        await fs.emptyDir(buildConfig.dist('macos'));
+        const noBundleConfigurationPath = node_path_1.default.join(buildConfig.tmp, 'macos', 'no-bundle.plist');
+        const build = async (arch) => {
+            const templateKey = (0, upload_util_1.templateShortKey)('macos', {
+                arch,
+                bin: config.bin,
+                sha: buildConfig.gitSha,
+                version: config.version,
+            });
+            const dist = buildConfig.dist(`macos/${templateKey}`);
+            const rootDir = buildConfig.workspace({ arch, platform: 'darwin' });
+            const writeNoBundleConfiguration = async () => {
+                await fs.mkdir(node_path_1.default.dirname(noBundleConfigurationPath), { recursive: true });
+                await fs.writeFile(noBundleConfigurationPath, noBundleConfiguration, { mode: 0o755 });
+            };
+            const writeScript = async (script) => {
+                const scriptLocation = script === 'uninstall' ? [rootDir, 'bin'] : [scriptsDir];
+                scriptLocation.push(script);
+                await fs.mkdir(node_path_1.default.dirname(node_path_1.default.join(...scriptLocation)), { recursive: true });
+                await fs.writeFile(node_path_1.default.join(...scriptLocation), scripts[script](config, flags['additional-cli']), {
+                    mode: 0o755,
+                });
+            };
+            await Promise.all([
+                writeNoBundleConfiguration(),
+                writeScript('preinstall'),
+                writeScript('postinstall'),
+                writeScript('uninstall'),
+            ]);
+            const args = [
+                '--root',
+                rootDir,
+                '--component-plist',
+                noBundleConfigurationPath,
+                '--identifier',
+                packageIdentifier,
+                '--version',
+                config.version,
+                '--install-location',
+                `/usr/local/lib/${config.dirname}`,
+                '--scripts',
+                scriptsDir,
+            ];
+            if (macos.sign) {
+                args.push('--sign', macos.sign);
+            }
+            else
+                this.debug('Skipping macOS pkg signing');
+            if (process.env.OSX_KEYCHAIN)
+                args.push('--keychain', process.env.OSX_KEYCHAIN);
+            args.push(dist);
+            await exec(`pkgbuild  ${args.join(' ')}`);
+        };
+        const arches = (0, util_1.uniq)(buildConfig.targets.filter((t) => t.platform === 'darwin').map((t) => t.arch));
+        await Promise.all(arches.map((a) => build(a)));
+    }
+}
+exports.default = PackMacos;

package/lib/commands/pack/tarballs.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class PackTarballs extends Command {
+    static description: string;
+    static flags: {
+        parallel: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'prune-lockfiles': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        root: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        sha: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tarball: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        targets: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        xz: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static summary: string;
+    run(): Promise<void>;
+}