@depup/oclif 4.22.92-depup.1

package/lib/commands/promote.js

@@ -0,0 +1,305 @@
+"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 client_s3_1 = require("@aws-sdk/client-s3");
+const core_1 = require("@oclif/core");
+const node_path_1 = __importDefault(require("node:path"));
+const aws_1 = __importDefault(require("../aws"));
+const Tarballs = __importStar(require("../tarballs"));
+const upload_util_1 = require("../upload-util");
+const util_1 = require("../util");
+const version_indexes_1 = require("../version-indexes");
+class Promote extends core_1.Command {
+    static description = 'Promote CLI builds to a S3 release channel.';
+    static flags = {
+        channel: core_1.Flags.string({ default: 'stable', description: 'Channel to promote to.', required: true }),
+        deb: core_1.Flags.boolean({ char: 'd', description: 'Promote debian artifacts.' }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Run the command without uploading to S3 or copying versioned tarballs/installers to channel.',
+        }),
+        'ignore-missing': core_1.Flags.boolean({
+            description: 'Ignore missing tarballs/installers and continue promoting the rest.',
+        }),
+        indexes: core_1.Flags.boolean({ description: 'Append the promoted urls into the index files.' }),
+        macos: core_1.Flags.boolean({ char: 'm', description: 'Promote macOS pkg.' }),
+        'max-age': core_1.Flags.string({ char: 'a', default: '86400', description: 'Cache control max-age in seconds.' }),
+        root: core_1.Flags.string({ char: 'r', default: '.', description: 'Path to the oclif CLI project root.', required: true }),
+        sha: core_1.Flags.string({ description: '7-digit short git commit SHA of the CLI to promote.', required: true }),
+        targets: core_1.Flags.string({ char: 't', description: 'Comma-separated targets to promote (e.g.: linux-arm,win32-x64).' }),
+        version: core_1.Flags.string({ description: 'Semantic version of the CLI to promote.', required: true }),
+        win: core_1.Flags.boolean({ char: 'w', description: 'Promote Windows exe.' }),
+        xz: core_1.Flags.boolean({ allowNo: true, description: 'Also upload xz.' }),
+    };
+    async run() {
+        const { flags } = await this.parse(Promote);
+        if (flags['ignore-missing']) {
+            this.warn("--ignore-missing flag is being used - This command will continue to run even if a promotion fails because it doesn't exist");
+        }
+        this.log(`Promoting v${flags.version} (${flags.sha}) to ${flags.channel} channel\n`);
+        const buildConfig = await Tarballs.buildConfig(flags.root, { targets: flags?.targets?.split(',') });
+        const { config, s3Config } = buildConfig;
+        const indexDefaults = {
+            maxAge: `max-age=${flags['max-age']}`,
+            s3Config,
+            version: flags.version,
+        };
+        if (!s3Config.bucket)
+            this.error('Cannot determine S3 bucket for promotion');
+        const awsDefaults = {
+            ACL: s3Config.acl ?? client_s3_1.ObjectCannedACL.public_read,
+            Bucket: s3Config.bucket,
+            CacheControl: indexDefaults.maxAge,
+            MetadataDirective: client_s3_1.MetadataDirective.REPLACE,
+        };
+        const cloudBucketCommitKey = (shortKey) => node_path_1.default.posix.join(s3Config.bucket, (0, upload_util_1.commitAWSDir)(flags.version, flags.sha, s3Config), shortKey);
+        const cloudChannelKey = (shortKey) => node_path_1.default.posix.join((0, upload_util_1.channelAWSDir)(flags.channel, s3Config), shortKey);
+        // copy tarballs manifests
+        const promoteManifest = async (target) => {
+            const manifest = (0, upload_util_1.templateShortKey)('manifest', {
+                arch: target.arch,
+                bin: config.bin,
+                platform: target.platform,
+                sha: flags.sha,
+                version: flags.version,
+            });
+            // strip version & sha so update/scripts can point to a static channel manifest
+            const unversionedManifest = manifest.replace(`-v${flags.version}-${flags.sha}`, '');
+            await aws_1.default.s3.copyObject({
+                ...awsDefaults,
+                CopySource: cloudBucketCommitKey(manifest),
+                Key: cloudChannelKey(unversionedManifest),
+            }, {
+                dryRun: flags['dry-run'],
+                ignoreMissing: flags['ignore-missing'],
+                namespace: unversionedManifest,
+            });
+        };
+        const promoteGzTarballs = async (target) => {
+            const versionedTarGzName = (0, upload_util_1.templateShortKey)('versioned', {
+                arch: target.arch,
+                bin: config.bin,
+                ext: '.tar.gz',
+                platform: target.platform,
+                sha: flags.sha,
+                version: flags.version,
+            });
+            const versionedTarGzKey = cloudBucketCommitKey(versionedTarGzName);
+            // strip version & sha so update/scripts can point to a static channel tarball
+            const unversionedTarGzName = versionedTarGzName.replace(`-v${flags.version}-${flags.sha}`, '');
+            const unversionedTarGzKey = cloudChannelKey(unversionedTarGzName);
+            await Promise.all([
+                aws_1.default.s3.copyObject({
+                    ...awsDefaults,
+                    CopySource: versionedTarGzKey,
+                    Key: unversionedTarGzKey,
+                }, {
+                    dryRun: flags['dry-run'],
+                    ignoreMissing: flags['ignore-missing'],
+                    namespace: unversionedTarGzName,
+                }),
+                ...(flags.indexes
+                    ? [
+                        (0, version_indexes_1.appendToIndex)({
+                            ...indexDefaults,
+                            dryRun: flags['dry-run'],
+                            filename: unversionedTarGzName,
+                            originalUrl: versionedTarGzKey,
+                        }),
+                    ]
+                    : []),
+            ]);
+        };
+        const promoteXzTarballs = async (target) => {
+            const versionedTarXzName = (0, upload_util_1.templateShortKey)('versioned', {
+                arch: target.arch,
+                bin: config.bin,
+                ext: '.tar.xz',
+                platform: target.platform,
+                sha: flags.sha,
+                version: flags.version,
+            });
+            const versionedTarXzKey = cloudBucketCommitKey(versionedTarXzName);
+            // strip version & sha so update/scripts can point to a static channel tarball
+            const unversionedTarXzName = versionedTarXzName.replace(`-v${flags.version}-${flags.sha}`, '');
+            const unversionedTarXzKey = cloudChannelKey(unversionedTarXzName);
+            await Promise.all([
+                aws_1.default.s3.copyObject({
+                    ...awsDefaults,
+                    CopySource: versionedTarXzKey,
+                    Key: unversionedTarXzKey,
+                }, {
+                    dryRun: flags['dry-run'],
+                    ignoreMissing: flags['ignore-missing'],
+                    namespace: unversionedTarXzName,
+                }),
+                ...(flags.indexes
+                    ? [
+                        (0, version_indexes_1.appendToIndex)({
+                            ...indexDefaults,
+                            dryRun: flags['dry-run'],
+                            filename: unversionedTarXzName,
+                            originalUrl: versionedTarXzKey,
+                        }),
+                    ]
+                    : []),
+            ]);
+        };
+        const promoteMacInstallers = async () => {
+            const arches = (0, util_1.uniq)(buildConfig.targets.filter((t) => t.platform === 'darwin').map((t) => t.arch));
+            await Promise.all(arches.map(async (arch) => {
+                const darwinPkg = (0, upload_util_1.templateShortKey)('macos', { arch, bin: config.bin, sha: flags.sha, version: flags.version });
+                const darwinCopySource = cloudBucketCommitKey(darwinPkg);
+                // strip version & sha so scripts can point to a static channel pkg
+                const unversionedPkg = darwinPkg.replace(`-v${flags.version}-${flags.sha}`, '');
+                await Promise.all([
+                    aws_1.default.s3.copyObject({
+                        ...awsDefaults,
+                        CopySource: darwinCopySource,
+                        Key: cloudChannelKey(unversionedPkg),
+                    }, {
+                        dryRun: flags['dry-run'],
+                        ignoreMissing: flags['ignore-missing'],
+                        namespace: unversionedPkg,
+                    }),
+                    ...(flags.indexes
+                        ? [
+                            (0, version_indexes_1.appendToIndex)({
+                                ...indexDefaults,
+                                dryRun: flags['dry-run'],
+                                filename: unversionedPkg,
+                                originalUrl: darwinCopySource,
+                            }),
+                        ]
+                        : []),
+                ]);
+            }));
+        };
+        const promoteWindowsInstallers = async () => {
+            // copy win exe
+            const arches = buildConfig.targets.filter((t) => t.platform === 'win32').map((t) => t.arch);
+            await Promise.all(arches.map(async (arch) => {
+                const winPkg = (0, upload_util_1.templateShortKey)('win32', { arch, bin: config.bin, sha: flags.sha, version: flags.version });
+                const winCopySource = cloudBucketCommitKey(winPkg);
+                // strip version & sha so scripts can point to a static channel exe
+                const unversionedExe = winPkg.replace(`-v${flags.version}-${flags.sha}`, '');
+                await Promise.all([
+                    aws_1.default.s3.copyObject({
+                        ...awsDefaults,
+                        CopySource: winCopySource,
+                        Key: cloudChannelKey(unversionedExe),
+                    }, {
+                        dryRun: flags['dry-run'],
+                        ignoreMissing: flags['ignore-missing'],
+                        namespace: unversionedExe,
+                    }),
+                    ...(flags.indexes
+                        ? [
+                            (0, version_indexes_1.appendToIndex)({
+                                ...indexDefaults,
+                                dryRun: flags['dry-run'],
+                                filename: unversionedExe,
+                                originalUrl: winCopySource,
+                            }),
+                        ]
+                        : []),
+                ]);
+                core_1.ux.action.stop('successfully');
+            }));
+        };
+        const promoteDebianAptPackages = async () => {
+            const arches = buildConfig.targets.filter((t) => t.platform === 'linux');
+            // copy debian artifacts
+            const debArtifacts = [
+                ...arches
+                    .filter((a) => !a.arch.includes('x86')) // See todo below
+                    .map((a) => (0, upload_util_1.templateShortKey)('deb', {
+                    arch: (0, upload_util_1.debArch)(a.arch),
+                    bin: config.bin,
+                    versionShaRevision: (0, upload_util_1.debVersion)(buildConfig),
+                })),
+                'Packages.gz',
+                'Packages.xz',
+                'Packages.bz2',
+                'Release',
+                'InRelease',
+                'Release.gpg',
+            ];
+            await Promise.all(debArtifacts.flatMap((artifact) => {
+                const debCopySource = cloudBucketCommitKey(`apt/${artifact}`);
+                const debKey = cloudChannelKey(`apt/${artifact}`);
+                // apt expects ../apt/dists/versionName/[artifacts] but oclif wants versions/sha/apt/[artifacts]
+                // see https://github.com/oclif/oclif/issues/347 for the AWS-redirect that solves this
+                // this workaround puts the code in both places that the redirect was doing
+                // with this, the docs are correct. The copies are all done in parallel so it shouldn't be too costly.
+                const workaroundKey = `${cloudChannelKey('apt/')}./${artifact}`;
+                return [
+                    aws_1.default.s3.copyObject({
+                        ...awsDefaults,
+                        CopySource: debCopySource,
+                        Key: debKey,
+                    }, {
+                        dryRun: flags['dry-run'],
+                        ignoreMissing: flags['ignore-missing'],
+                        namespace: debKey,
+                    }),
+                    aws_1.default.s3.copyObject({
+                        ...awsDefaults,
+                        CopySource: debCopySource,
+                        Key: workaroundKey,
+                    }, {
+                        dryRun: flags['dry-run'],
+                        ignoreMissing: flags['ignore-missing'],
+                        namespace: workaroundKey,
+                    }),
+                ];
+            }));
+        };
+        await Promise.all([
+            ...buildConfig.targets.flatMap((target) => [
+                // always promote the manifest and gz
+                promoteManifest(target),
+                promoteGzTarballs(target),
+            ]),
+            ...(flags.xz ? buildConfig.targets.map((target) => promoteXzTarballs(target)) : []),
+            ...(flags.macos ? [promoteMacInstallers()] : []),
+            ...(flags.win ? [promoteWindowsInstallers()] : []),
+            ...(flags.deb ? [promoteDebianAptPackages()] : []),
+        ]);
+    }
+}
+exports.default = Promote;

package/lib/commands/readme.d.ts

@@ -0,0 +1,19 @@
+import { Command, Interfaces } from '@oclif/core';
+export default class Readme extends Command {
+    static description: string;
+    static flags: {
+        aliases: Interfaces.BooleanFlag<boolean>;
+        'dry-run': Interfaces.BooleanFlag<boolean>;
+        multi: Interfaces.BooleanFlag<boolean>;
+        'nested-topics-depth': Interfaces.OptionFlag<number | undefined, Interfaces.CustomOptions>;
+        'output-dir': Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        'plugin-directory': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        'readme-path': Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        'repository-prefix': Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        'tsconfig-path': Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        version: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    };
+    static summary: string;
+    private flags;
+    run(): Promise<string>;
+}

package/lib/commands/readme.js

@@ -0,0 +1,143 @@
+"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_path_1 = __importDefault(require("node:path"));
+const readme_generator_1 = __importDefault(require("../readme-generator"));
+class Readme extends core_1.Command {
+    static description = `The readme must have any of the following tags inside of it for it to be replaced or else it will do nothing:
+# Usage
+<!-- usage -->
+# Commands
+<!-- commands -->
+# Table of contents
+<!-- toc -->
+
+Customize the code URL prefix by setting oclif.repositoryPrefix in package.json.
+`;
+    static flags = {
+        aliases: core_1.Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Include aliases in the command list.',
+        }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Prints the generated README without modifying the file.',
+        }),
+        multi: core_1.Flags.boolean({
+            description: 'Create a different markdown page for each topic.',
+        }),
+        'nested-topics-depth': core_1.Flags.integer({
+            dependsOn: ['multi'],
+            description: 'Max nested topics depth for multi markdown page generation. Use with --multi enabled.',
+        }),
+        'output-dir': core_1.Flags.string({
+            aliases: ['dir'],
+            default: 'docs',
+            description: 'Output directory for multi docs.',
+            required: true,
+        }),
+        'plugin-directory': core_1.Flags.string({
+            description: 'Plugin directory to generate README for. Defaults to the current directory.',
+        }),
+        'readme-path': core_1.Flags.string({
+            default: 'README.md',
+            description: 'Path to the README file.',
+            required: true,
+        }),
+        'repository-prefix': core_1.Flags.string({
+            description: 'A template string used to build links to the source code.',
+        }),
+        'tsconfig-path': core_1.Flags.string({
+            default: 'tsconfig.json',
+            description: 'Path to the tsconfig file',
+        }),
+        version: core_1.Flags.string({
+            description: 'Version to use in readme links. Defaults to the version in package.json.',
+        }),
+    };
+    static summary = 'Adds commands to README.md in current directory.';
+    flags;
+    async run() {
+        const { flags } = await this.parse(Readme);
+        this.flags = flags;
+        this.flags['plugin-directory'] ??= process.cwd();
+        const readmePath = node_path_1.default.resolve(this.flags['plugin-directory'], flags['readme-path']);
+        const tsConfigPath = node_path_1.default.resolve(this.flags['plugin-directory'], flags['tsconfig-path']);
+        if (await fs.pathExists(tsConfigPath)) {
+            const { default: JSONC } = await import('tiny-jsonc');
+            const tsConfigRaw = await fs.readFile(tsConfigPath, 'utf8');
+            const tsConfig = JSONC.parse(tsConfigRaw);
+            const outDir = tsConfig.compilerOptions?.outDir ?? 'lib';
+            if (!(await fs.pathExists(outDir))) {
+                this.warn(`No compiled source found at ${outDir}. Some commands may be missing.`);
+            }
+        }
+        const config = await core_1.Config.load({
+            devPlugins: false,
+            root: this.flags['plugin-directory'],
+            userPlugins: false,
+        });
+        try {
+            const p = require.resolve('@oclif/plugin-legacy', { paths: [this.flags['plugin-directory']] });
+            const plugin = new core_1.Plugin({ root: p, type: 'core' });
+            await plugin.load();
+            config.plugins.set(plugin.name, plugin);
+        }
+        catch { }
+        await config.runHook('init', { argv: this.argv, id: 'readme' });
+        const generator = new readme_generator_1.default(config, {
+            aliases: this.flags.aliases,
+            dryRun: this.flags['dry-run'],
+            multi: this.flags.multi,
+            nestedTopicsDepth: this.flags['nested-topics-depth'],
+            outputDir: this.flags['output-dir'],
+            pluginDir: this.flags['plugin-directory'],
+            readmePath,
+            repositoryPrefix: this.flags['repository-prefix'],
+            version: this.flags.version,
+        });
+        const readme = await generator.generate();
+        if (this.flags['dry-run']) {
+            this.log(readme);
+        }
+        return readme;
+    }
+}
+exports.default = Readme;

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

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class UploadDeb extends Command {
+    static description: string;
+    static flags: {
+        'dry-run': 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>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/upload/deb.js

@@ -0,0 +1,113 @@
+"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("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const aws_1 = __importDefault(require("../../aws"));
+const log_1 = require("../../log");
+const Tarballs = __importStar(require("../../tarballs"));
+const upload_util_1 = require("../../upload-util");
+class UploadDeb extends core_1.Command {
+    static description = 'Upload deb package built with `pack deb`.';
+    static flags = {
+        'dry-run': core_1.Flags.boolean({ description: 'Run the command without uploading to S3.' }),
+        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,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(UploadDeb);
+        const buildConfig = await Tarballs.buildConfig(flags.root, { sha: flags?.sha });
+        const { config, s3Config } = buildConfig;
+        const dist = (f) => buildConfig.dist(node_path_1.default.join('deb', f));
+        const S3Options = {
+            ACL: s3Config.acl || 'public-read',
+            Bucket: s3Config.bucket,
+        };
+        if (!fs.existsSync(dist('Release')))
+            this.error('Cannot find debian artifacts', {
+                suggestions: ['Run "oclif pack deb" before uploading'],
+            });
+        const cloudKeyBase = (0, upload_util_1.commitAWSDir)(config.pjson.version, buildConfig.gitSha, s3Config);
+        const upload = (file) => {
+            const cloudKey = `${cloudKeyBase}/apt/${file}`;
+            return aws_1.default.s3.uploadFile(dist(file), { ...S3Options, CacheControl: 'max-age=86400', Key: cloudKey }, {
+                dryRun: flags['dry-run'],
+            });
+        };
+        // apt expects ../apt/dists/versionName/[artifacts] but oclif wants versions/sha/apt/[artifacts]
+        // see https://github.com/oclif/oclif/issues/347 for the AWS-redirect that solves this
+        // this workaround puts the code in both places that the redirect was doing
+        // with this, the docs are correct. The copies are all done in parallel so it shouldn't be too costly.
+        const uploadWorkaround = (file) => {
+            const cloudKey = `${cloudKeyBase}/apt/./${file}`;
+            return aws_1.default.s3.uploadFile(dist(file), { ...S3Options, CacheControl: 'max-age=86400', Key: cloudKey }, {
+                dryRun: flags['dry-run'],
+            });
+        };
+        const uploadDeb = async (arch) => {
+            const deb = (0, upload_util_1.templateShortKey)('deb', {
+                arch,
+                bin: config.bin,
+                versionShaRevision: (0, upload_util_1.debVersion)(buildConfig),
+            });
+            if (fs.existsSync(dist(deb)))
+                await Promise.all([upload(deb), uploadWorkaround(deb)]);
+        };
+        (0, log_1.log)(`starting upload of deb artifacts for v${config.version}-${buildConfig.gitSha}`);
+        const arches = buildConfig.targets.filter((t) => t.platform === 'linux');
+        await Promise.all([
+            ...arches.map((a) => uploadDeb((0, upload_util_1.debArch)(a.arch))),
+            upload('Packages.gz'),
+            upload('Packages.xz'),
+            upload('Packages.bz2'),
+            upload('Release'),
+            uploadWorkaround('Packages.gz'),
+            uploadWorkaround('Packages.xz'),
+            uploadWorkaround('Packages.bz2'),
+            uploadWorkaround('Release'),
+            ...(fs.existsSync(dist('InRelease')) ? [upload('InRelease'), uploadWorkaround('InRelease')] : []),
+            ...(fs.existsSync(dist('Release.gpg')) ? [upload('Release.gpg'), uploadWorkaround('Release.gpg')] : []),
+        ]);
+        (0, log_1.log)(`done uploading deb artifacts for v${config.version}-${buildConfig.gitSha}`);
+    }
+}
+exports.default = UploadDeb;

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

@@ -0,0 +1,11 @@
+import { Command, Interfaces } from '@oclif/core';
+export default class UploadMacos extends Command {
+    static description: string;
+    static flags: {
+        'dry-run': Interfaces.BooleanFlag<boolean>;
+        root: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+        sha: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+        targets: Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>;
+    };
+    run(): Promise<void>;
+}