@depup/oclif 4.22.92-depup.1

package/lib/tarballs/build.js

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+const core_1 = require("@oclif/core");
+const find_yarn_workspace_root_1 = __importDefault(require("find-yarn-workspace-root"));
+const fs_extra_1 = require("fs-extra");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const log_1 = require("../log");
+const upload_util_1 = require("../upload-util");
+const util_1 = require("../util");
+const bin_1 = require("./bin");
+const node_1 = require("./node");
+const exec = (0, node_util_1.promisify)(node_child_process_1.exec);
+const pack = async (from, to, c) => {
+    const cwd = node_path_1.default.dirname(from);
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(to), { recursive: true });
+    (0, log_1.log)(`packing tarball from ${(0, util_1.prettifyPaths)(node_path_1.default.dirname(from))} to ${(0, util_1.prettifyPaths)(to)}`);
+    const platformFlag = c.tarFlags?.[process.platform] ?? '';
+    if (to.endsWith('gz')) {
+        return exec(`tar czf ${to} ${node_path_1.default.basename(from)} ${platformFlag}`, { cwd });
+    }
+    await exec(`tar cfJ ${to} ${node_path_1.default.basename(from)} ${platformFlag}`, { cwd });
+};
+const isYarnProject = (yarnRootPath) => {
+    const yarnLockFileName = 'yarn.lock';
+    const rootYarnLockFilePath = node_path_1.default.join(yarnRootPath, yarnLockFileName);
+    return (0, node_fs_1.existsSync)(rootYarnLockFilePath);
+};
+const copyYarnDirectory = async (relativePath, yarnRootPath, workspacePath) => {
+    const rootYarnDirectoryPath = node_path_1.default.join(yarnRootPath, relativePath);
+    const workspaceYarnDirectoryPath = node_path_1.default.join(workspacePath, relativePath);
+    if ((0, node_fs_1.existsSync)(rootYarnDirectoryPath)) {
+        // create the directory if it does not exist
+        if (!(0, node_fs_1.existsSync)(workspaceYarnDirectoryPath)) {
+            await (0, promises_1.mkdir)(workspaceYarnDirectoryPath, { recursive: true });
+        }
+        // recursively copy all files in the directory
+        await (0, fs_extra_1.copy)(rootYarnDirectoryPath, workspaceYarnDirectoryPath);
+    }
+};
+const copyCoreYarnFiles = async (yarnRootPath, workspacePath) => {
+    // copy yarn dependencies lock file
+    const yarnLockFileName = 'yarn.lock';
+    const rootYarnLockFilePath = node_path_1.default.join(yarnRootPath, yarnLockFileName);
+    const workspaceYarnLockFilePath = node_path_1.default.join(workspacePath, yarnLockFileName);
+    if ((0, node_fs_1.existsSync)(rootYarnLockFilePath)) {
+        await (0, fs_extra_1.copy)(rootYarnLockFilePath, workspaceYarnLockFilePath);
+    }
+    // copy yarn configuration file
+    const yarnConfigFileName = '.yarnrc.yml';
+    const rootYarnConfigFilePath = node_path_1.default.join(yarnRootPath, yarnConfigFileName);
+    const workspaceYarnConfigFilePath = node_path_1.default.join(workspacePath, yarnConfigFileName);
+    if ((0, node_fs_1.existsSync)(rootYarnConfigFilePath)) {
+        await (0, fs_extra_1.copy)(rootYarnConfigFilePath, workspaceYarnConfigFilePath);
+    }
+    // copy yarn releases e.g. yarn may be installed via a local config path like "yarnPath"
+    await copyYarnDirectory('./.yarn/releases/', yarnRootPath, workspacePath);
+    // copy yarn plugins if they exists
+    await copyYarnDirectory('./.yarn/plugins/', yarnRootPath, workspacePath);
+    // copy yarn patches if they exists
+    await copyYarnDirectory('./.yarn/patches/', yarnRootPath, workspacePath);
+};
+async function build(c, options = {}) {
+    (0, log_1.log)(`gathering workspace for ${c.config.bin} to ${c.workspace()}`);
+    await extractCLI(options.tarball ?? (await packCLI(c)), c);
+    await updatePJSON(c);
+    await addDependencies(c);
+    await (0, bin_1.writeBinScripts)({
+        baseWorkspace: c.workspace(),
+        config: c.config,
+        nodeOptions: c.nodeOptions,
+        nodeVersion: c.nodeVersion,
+    });
+    await pretarball(c);
+    if (options.pruneLockfiles) {
+        await removeLockfiles(c);
+    }
+    if (!c.updateConfig.s3?.host || !c.updateConfig.s3?.bucket) {
+        core_1.ux.warn('No S3 bucket or host configured. CLI will not be able to update itself.');
+    }
+    const targetsToBuild = c.targets.filter((t) => !options.platform || options.platform === t.platform);
+    if (options.parallel) {
+        (0, log_1.log)(`will build ${targetsToBuild.length} targets in parallel`);
+        await Promise.all(targetsToBuild.map((t) => buildTarget(t, c, options)));
+    }
+    else {
+        (0, log_1.log)(`will build ${targetsToBuild.length} targets sequentially`);
+        for (const target of targetsToBuild) {
+            // eslint-disable-next-line no-await-in-loop
+            await buildTarget(target, c, options);
+        }
+        (0, log_1.log)(`finished building ${targetsToBuild.length} targets sequentially`);
+    }
+}
+const isLockFile = (f) => f.endsWith('package-lock.json') ||
+    f.endsWith('yarn.lock') ||
+    f.endsWith('npm-shrinkwrap.json') ||
+    f.endsWith('oclif.lock') ||
+    f.endsWith('pnpm-lock.yaml');
+/** recursively remove all lockfiles from tarball after installing dependencies */
+const removeLockfiles = async (c) => {
+    const files = await (0, promises_1.readdir)(c.workspace(), { recursive: true });
+    const lockfiles = files.filter((f) => isLockFile(f)).map((f) => node_path_1.default.join(c.workspace(), f));
+    (0, log_1.log)(`removing ${lockfiles.length} lockfiles`);
+    await Promise.all(lockfiles.map((f) => (0, fs_extra_1.remove)(f)));
+};
+/** runs the pretarball script from the cli being packed */
+const pretarball = async (c) => {
+    const pjson = await (0, fs_extra_1.readJSON)(node_path_1.default.join(c.workspace(), 'package.json'));
+    if (!pjson.scripts.pretarball)
+        return;
+    const yarnRoot = (0, find_yarn_workspace_root_1.default)(c.root) || c.root;
+    let script = 'npm run pretarball';
+    if ((0, node_fs_1.existsSync)(node_path_1.default.join(yarnRoot, 'yarn.lock')))
+        script = 'yarn run pretarball';
+    else if ((0, node_fs_1.existsSync)(node_path_1.default.join(c.root, 'pnpm-lock.yaml')))
+        script = 'pnpm run pretarball';
+    (0, log_1.log)(`running pretarball via ${script} in ${c.workspace()}`);
+    await exec(script, { cwd: c.workspace() });
+};
+const updatePJSON = async (c) => {
+    const pjsonPath = node_path_1.default.join(c.workspace(), 'package.json');
+    const pjson = await (0, fs_extra_1.readJSON)(pjsonPath);
+    pjson.version = c.config.version;
+    pjson.oclif = pjson.oclif ?? {};
+    pjson.oclif.update = pjson.oclif.update ?? {};
+    pjson.oclif.update.s3 = pjson.oclif.update.s3 ?? {};
+    pjson.oclif.update.s3.bucket = c.s3Config.bucket;
+    await (0, fs_extra_1.writeJSON)(pjsonPath, pjson, { spaces: 2 });
+};
+const addDependencies = async (c) => {
+    const yarnRoot = (0, find_yarn_workspace_root_1.default)(c.root) || c.root;
+    if (isYarnProject(yarnRoot)) {
+        await copyCoreYarnFiles(yarnRoot, c.workspace());
+        const { stdout } = await exec('yarn -v');
+        const yarnVersion = stdout.charAt(0);
+        if (yarnVersion === '1') {
+            await exec('yarn --no-progress --production --non-interactive', { cwd: c.workspace() });
+        }
+        else if (yarnVersion === '2') {
+            throw new Error('Yarn 2 is not supported yet. Try using Yarn 1, or Yarn 3');
+        }
+        else {
+            try {
+                await exec('yarn workspaces focus --production', { cwd: c.workspace() });
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('Command not found')) {
+                    throw new Error('Missing workspace tools. Run `yarn plugin import workspace-tools`.');
+                }
+                throw error;
+            }
+        }
+    }
+    else if ((0, node_fs_1.existsSync)(node_path_1.default.join(c.root, 'pnpm-lock.yaml'))) {
+        await (0, fs_extra_1.copy)(node_path_1.default.join(c.root, 'pnpm-lock.yaml'), node_path_1.default.join(c.workspace(), 'pnpm-lock.yaml'));
+        await exec('pnpm install --production', { cwd: c.workspace() });
+    }
+    else {
+        const lockpath = (0, node_fs_1.existsSync)(node_path_1.default.join(c.root, 'package-lock.json'))
+            ? node_path_1.default.join(c.root, 'package-lock.json')
+            : node_path_1.default.join(c.root, 'npm-shrinkwrap.json');
+        await (0, fs_extra_1.copy)(lockpath, node_path_1.default.join(c.workspace(), node_path_1.default.basename(lockpath)));
+        await exec('npm install --production', { cwd: c.workspace() });
+    }
+};
+const packCLI = async (c) => {
+    const { stdout } = await exec('npm pack --unsafe-perm', { cwd: c.root });
+    return node_path_1.default.join(c.root, stdout.trim().split('\n').pop());
+};
+const extractCLI = async (tarball, c) => {
+    const workspace = c.workspace();
+    await (0, fs_extra_1.emptyDir)(workspace);
+    const tarballNewLocation = node_path_1.default.join(workspace, node_path_1.default.basename(tarball));
+    await (0, fs_extra_1.move)(tarball, tarballNewLocation);
+    const tarCommand = `tar -xzf "${tarballNewLocation}"${process.platform === 'win32' ? ' --force-local' : ''}`;
+    await exec(tarCommand, { cwd: workspace });
+    const files = await (0, promises_1.readdir)(node_path_1.default.join(workspace, 'package'), { withFileTypes: true });
+    await Promise.all(files.map((i) => (0, fs_extra_1.move)(node_path_1.default.join(workspace, 'package', i.name), node_path_1.default.join(workspace, i.name))));
+    await Promise.all([
+        (0, promises_1.rm)(node_path_1.default.join(workspace, 'package'), { recursive: true }),
+        (0, promises_1.rm)(node_path_1.default.join(workspace, node_path_1.default.basename(tarball)), { recursive: true }),
+        (0, fs_extra_1.remove)(node_path_1.default.join(workspace, 'bin', 'run.cmd')),
+    ]);
+};
+const buildTarget = async (target, c, options) => {
+    const workspace = c.workspace(target);
+    const { arch, platform } = target;
+    const { bin, version } = c.config;
+    const { gitSha: sha } = c;
+    const templateShortKeyCommonOptions = { arch, bin, platform, sha, version };
+    const [gzLocalKey, xzLocalKey] = ['.tar.gz', '.tar.xz'].map((ext) => (0, upload_util_1.templateShortKey)('versioned', { ...templateShortKeyCommonOptions, ext }));
+    const base = node_path_1.default.basename(gzLocalKey);
+    (0, log_1.log)(`building target ${base}`);
+    (0, log_1.log)('copying workspace', c.workspace(), workspace);
+    await (0, fs_extra_1.emptyDir)(workspace);
+    await (0, fs_extra_1.copy)(c.workspace(), workspace);
+    await (0, node_1.fetchNodeBinary)({
+        arch,
+        nodeVersion: c.nodeVersion,
+        output: node_path_1.default.join(workspace, 'bin', 'node'),
+        platform,
+        tmp: node_path_1.default.join(c.config.root, 'tmp'),
+    });
+    if (options.pack === false)
+        return;
+    if (options.parallel) {
+        await Promise.all([
+            pack(workspace, c.dist(gzLocalKey), c),
+            ...(c.xz ? [pack(workspace, c.dist(xzLocalKey), c)] : []),
+        ]);
+    }
+    else {
+        await pack(workspace, c.dist(gzLocalKey), c);
+        if (c.xz)
+            await pack(workspace, c.dist(xzLocalKey), c);
+    }
+    if (!c.updateConfig.s3?.host)
+        return;
+    const rollout = typeof c.updateConfig.autoupdate === 'object' && c.updateConfig.autoupdate.rollout;
+    const gzCloudKey = `${(0, upload_util_1.commitAWSDir)(version, sha, c.updateConfig.s3)}/${gzLocalKey}`;
+    const xzCloudKey = `${(0, upload_util_1.commitAWSDir)(version, sha, c.updateConfig.s3)}/${xzLocalKey}`;
+    const [sha256gz, sha256xz] = await Promise.all([
+        (0, util_1.hash)('sha256', c.dist(gzLocalKey)),
+        ...(c.xz ? [(0, util_1.hash)('sha256', c.dist(xzLocalKey))] : []),
+    ]);
+    const manifest = {
+        baseDir: (0, upload_util_1.templateShortKey)('baseDir', { ...target, bin }),
+        gz: c.config.s3Url(gzCloudKey),
+        node: {
+            compatible: c.config.pjson.engines.node,
+            recommended: c.nodeVersion,
+        },
+        rollout: rollout === false ? undefined : rollout,
+        sha,
+        sha256gz,
+        sha256xz,
+        version,
+        xz: c.xz ? c.config.s3Url(xzCloudKey) : undefined,
+    };
+    const manifestFilepath = c.dist((0, upload_util_1.templateShortKey)('manifest', templateShortKeyCommonOptions));
+    await (0, fs_extra_1.writeJSON)(manifestFilepath, manifest, { spaces: 2 });
+};

package/lib/tarballs/config.d.ts

@@ -0,0 +1,45 @@
+import { ObjectCannedACL } from '@aws-sdk/client-s3';
+import { Interfaces } from '@oclif/core';
+export declare const TARGETS: string[];
+type TarFlags = Interfaces.OclifConfiguration['tarFlags'];
+export type S3Config = BuildConfig['updateConfig']['s3'] & {
+    acl?: ObjectCannedACL;
+} & {
+    folder?: string;
+    indexVersionLimit?: number;
+};
+export type UpdateConfig = Interfaces.OclifConfiguration['update'] & {
+    s3?: Interfaces.S3 & {
+        acl?: ObjectCannedACL;
+    };
+};
+export type BuildConfig = {
+    config: Interfaces.Config;
+    dist(input: string): string;
+    gitSha: string;
+    nodeOptions: string[];
+    nodeVersion: string;
+    root: string;
+    s3Config: S3Config;
+    tarFlags?: TarFlags;
+    targets: {
+        arch: Interfaces.ArchTypes;
+        platform: Interfaces.PlatformTypes;
+    }[];
+    tmp: string;
+    updateConfig: UpdateConfig;
+    workspace(target?: {
+        arch: Interfaces.ArchTypes;
+        platform: Interfaces.PlatformTypes;
+    }): string;
+    xz: boolean;
+};
+export declare function gitSha(cwd: string, options?: {
+    short?: boolean;
+}): Promise<string>;
+export declare function buildConfig(root: string, options?: {
+    sha?: string;
+    targets?: string[];
+    xz?: boolean;
+}): Promise<BuildConfig>;
+export {};

package/lib/tarballs/config.js

@@ -0,0 +1,132 @@
+"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 });
+exports.TARGETS = void 0;
+exports.gitSha = gitSha;
+exports.buildConfig = buildConfig;
+const core_1 = require("@oclif/core");
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const semver = __importStar(require("semver"));
+const upload_util_1 = require("../upload-util");
+const util_1 = require("../util");
+const exec = (0, node_util_1.promisify)(node_child_process_1.exec);
+exports.TARGETS = [
+    'linux-x64',
+    'linux-arm',
+    'linux-arm64',
+    'win32-x64',
+    'win32-x86',
+    'win32-arm64',
+    'darwin-x64',
+    'darwin-arm64',
+];
+const DEFAULT_TAR_FLAGS = { win32: '--force-local' };
+async function gitSha(cwd, options = {}) {
+    const args = options.short ? ['rev-parse', '--short', 'HEAD'] : ['rev-parse', 'HEAD'];
+    const { stdout } = await exec(`git ${args.join(' ')}`, { cwd });
+    return stdout.trim();
+}
+async function Tmp(config) {
+    const tmp = node_path_1.default.join(config.root, 'tmp');
+    await (0, promises_1.mkdir)(tmp, { recursive: true });
+    return tmp;
+}
+async function buildConfig(root, options = {}) {
+    const config = await core_1.Config.load({ devPlugins: false, root: node_path_1.default.resolve(root), userPlugins: false });
+    root = config.root;
+    const _gitSha = options.sha ?? (await gitSha(root, { short: true }));
+    // eslint-disable-next-line new-cap
+    const tmp = await Tmp(config);
+    const updateConfig = (config.pjson.oclif.update || {});
+    updateConfig.s3 = updateConfig.s3 || {};
+    const nodeVersion = updateConfig.node?.version || process.versions.node;
+    const nodeOptions = (0, util_1.castArray)((updateConfig.node ?? {}).options ?? []);
+    const targets = (0, util_1.compact)(options.targets || updateConfig.node?.targets || exports.TARGETS)
+        .filter((t) => {
+        if (t === 'darwin-arm64' && semver.lt(nodeVersion, '16.0.0')) {
+            core_1.ux.warn('darwin-arm64 is only supported for node >=16.0.0. Skipping...');
+            return false;
+        }
+        if (t === 'linux-arm' && semver.gt(nodeVersion, '24.0.0')) {
+            core_1.ux.warn('linux-arm is not supported for Node.js 24 and later. Skipping...');
+            return false;
+        }
+        if (t === 'win32-x86' && semver.gt(nodeVersion, '24.0.0')) {
+            core_1.ux.warn('win32-x86 is not supported for Node.js 24 and later. Skipping...');
+            return false;
+        }
+        if (t === 'win32-arm64' && semver.lt(nodeVersion, '20.0.0')) {
+            core_1.ux.warn('win32-arm64 is only supported for node >=20.0.0. Skipping...');
+            return false;
+        }
+        return true;
+    })
+        .map((t) => {
+        const [platform, arch] = t.split('-');
+        return { arch, platform };
+    });
+    const s3Config = {
+        ...updateConfig.s3,
+        acl: updateConfig.s3.acl,
+    };
+    const existingTarFlags = config.pjson.oclif.tarFlags;
+    const tarFlags = existingTarFlags ? { ...DEFAULT_TAR_FLAGS, ...existingTarFlags } : DEFAULT_TAR_FLAGS;
+    return {
+        config,
+        dist: (...args) => node_path_1.default.join(config.root, 'dist', ...args),
+        gitSha: _gitSha,
+        nodeOptions,
+        nodeVersion,
+        root,
+        s3Config,
+        tarFlags,
+        targets,
+        tmp,
+        updateConfig,
+        workspace(target) {
+            const base = node_path_1.default.join(config.root, 'tmp');
+            if (target && target.platform)
+                return node_path_1.default.join(base, [target.platform, target.arch].join('-'), (0, upload_util_1.templateShortKey)('baseDir', { bin: config.bin }));
+            return node_path_1.default.join(base, (0, upload_util_1.templateShortKey)('baseDir', { bin: config.bin }));
+        },
+        xz: options?.xz ?? updateConfig?.s3?.xz ?? true,
+    };
+}

package/lib/tarballs/index.d.ts

@@ -0,0 +1,4 @@
+export * from './bin';
+export * from './build';
+export * from './config';
+export * from './node';

package/lib/tarballs/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bin"), exports);
+__exportStar(require("./build"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./node"), exports);

package/lib/tarballs/node.d.ts

@@ -0,0 +1,10 @@
+import { Interfaces } from '@oclif/core';
+type Options = {
+    arch: 'armv7l' | Interfaces.ArchTypes;
+    nodeVersion: string;
+    output: string;
+    platform: Interfaces.PlatformTypes;
+    tmp: string;
+};
+export declare function fetchNodeBinary({ arch, nodeVersion, output, platform, tmp }: Options): Promise<string>;
+export {};

package/lib/tarballs/node.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchNodeBinary = fetchNodeBinary;
+const async_retry_1 = __importDefault(require("async-retry"));
+const fs_extra_1 = require("fs-extra");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const promises_2 = require("node:stream/promises");
+const node_util_1 = require("node:util");
+const log_1 = require("../log");
+const util_1 = require("../util");
+const exec = (0, node_util_1.promisify)(node_child_process_1.exec);
+const RETRY_TIMEOUT_MS = 1000;
+async function fetchNodeBinary({ arch, nodeVersion, output, platform, tmp }) {
+    if (arch === 'arm')
+        arch = 'armv7l';
+    let nodeBase = `node-v${nodeVersion}-${platform}-${arch}`;
+    let tarball = node_path_1.default.join(tmp, 'node', `${nodeBase}.tar.xz`);
+    let url = `https://nodejs.org/dist/v${nodeVersion}/${nodeBase}.tar.xz`;
+    if (platform === 'win32') {
+        await (0, util_1.checkFor7Zip)();
+        nodeBase = `node-v${nodeVersion}-win-${arch}`;
+        tarball = node_path_1.default.join(tmp, 'node', `${nodeBase}.7z`);
+        url = `https://nodejs.org/dist/v${nodeVersion}/${nodeBase}.7z`;
+        output += '.exe';
+    }
+    let cache = node_path_1.default.join(tmp, 'cache', `node-v${nodeVersion}-${platform}-${arch}`);
+    if (platform === 'win32')
+        cache += '.exe';
+    const download = async () => {
+        (0, log_1.log)(`downloading ${nodeBase} (${url})`);
+        await Promise.all([(0, fs_extra_1.ensureDir)(node_path_1.default.join(tmp, 'cache', nodeVersion)), (0, fs_extra_1.ensureDir)(node_path_1.default.join(tmp, 'node'))]);
+        const shasums = node_path_1.default.join(tmp, 'cache', nodeVersion, 'SHASUMS256.txt.asc');
+        const { default: got } = await import('got');
+        if (!(0, node_fs_1.existsSync)(shasums)) {
+            await (0, promises_2.pipeline)(got.stream(`https://nodejs.org/dist/v${nodeVersion}/SHASUMS256.txt.asc`), (0, node_fs_1.createWriteStream)(shasums));
+        }
+        const basedir = node_path_1.default.dirname(tarball);
+        await (0, promises_1.mkdir)(basedir, { recursive: true });
+        await (0, promises_2.pipeline)(got.stream(url), (0, node_fs_1.createWriteStream)(tarball));
+        if (platform !== 'win32')
+            await exec(`grep "${node_path_1.default.basename(tarball)}" "${shasums}" | shasum -a 256 -c -`, { cwd: basedir });
+    };
+    const extract = async () => {
+        (0, log_1.log)(`extracting ${nodeBase}`);
+        const nodeTmp = node_path_1.default.join(tmp, 'node');
+        await (0, promises_1.mkdir)(nodeTmp, { recursive: true });
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(cache), { recursive: true });
+        if (platform === 'win32') {
+            await exec(`7z x -bd -y "${tarball}"`, { cwd: nodeTmp });
+            await (0, fs_extra_1.move)(node_path_1.default.join(nodeTmp, nodeBase, 'node.exe'), node_path_1.default.join(cache, 'node.exe'));
+        }
+        else {
+            await exec(`tar -C "${tmp}/node" -xJf "${tarball}"`);
+            await (0, fs_extra_1.move)(node_path_1.default.join(nodeTmp, nodeBase, 'bin', 'node'), node_path_1.default.join(cache, 'node'));
+        }
+    };
+    if (!(0, node_fs_1.existsSync)(cache)) {
+        await (0, async_retry_1.default)(download, {
+            factor: 1,
+            maxTimeout: RETRY_TIMEOUT_MS,
+            minTimeout: RETRY_TIMEOUT_MS,
+            onRetry(_e, attempt) {
+                (0, log_1.log)(`retrying node download (attempt ${attempt})`);
+            },
+            retries: 3,
+        });
+        await extract();
+    }
+    await (0, fs_extra_1.copy)(node_path_1.default.join(cache, getFilename(platform)), output);
+    return output;
+}
+const getFilename = (platform) => (platform === 'win32' ? 'node.exe' : 'node');

package/lib/upload-util.d.ts

@@ -0,0 +1,17 @@
+import { Interfaces } from '@oclif/core';
+import { BuildConfig as TarballConfig } from './tarballs/config';
+export declare function commitAWSDir(version: string, sha: string, s3Config: TarballConfig['s3Config']): string;
+export declare function channelAWSDir(channel: string, s3Config: TarballConfig['s3Config']): string;
+type TemplateOptions = Interfaces.Config.s3Key.Options | {
+    arch?: DebArch | Interfaces.ArchTypes;
+    bin?: string;
+    ext?: '.tar.gz' | '.tar.xz';
+    sha?: string;
+    version?: string;
+    versionShaRevision?: string;
+};
+export declare function templateShortKey(type: 'deb' | 'macos' | 'win32' | keyof Interfaces.S3Templates, options?: TemplateOptions): string;
+export type DebArch = 'amd64' | 'arm64' | 'armel' | 'i386';
+export declare function debArch(arch: Interfaces.ArchTypes): DebArch;
+export declare function debVersion(buildConfig: TarballConfig): string;
+export {};

package/lib/upload-util.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitAWSDir = commitAWSDir;
+exports.channelAWSDir = channelAWSDir;
+exports.templateShortKey = templateShortKey;
+exports.debArch = debArch;
+exports.debVersion = debVersion;
+const ejs_1 = require("ejs");
+const node_path_1 = __importDefault(require("node:path"));
+function commitAWSDir(version, sha, s3Config) {
+    let s3SubDir = s3Config.folder || '';
+    if (s3SubDir !== '' && s3SubDir.slice(-1) !== '/')
+        s3SubDir = `${s3SubDir}/`;
+    return node_path_1.default.posix.join(s3SubDir, 'versions', version, sha);
+}
+function channelAWSDir(channel, s3Config) {
+    let s3SubDir = s3Config.folder || '';
+    if (s3SubDir !== '' && s3SubDir.slice(-1) !== '/')
+        s3SubDir = `${s3SubDir}/`;
+    return node_path_1.default.posix.join(s3SubDir, 'channels', channel);
+}
+// TODO: refactor this key name lookup helper to oclif/core
+function templateShortKey(type, options) {
+    if (!options)
+        options = {
+            root: '.',
+        };
+    const templates = {
+        baseDir: '<%- bin %>',
+        deb: '<%- bin %>_<%- versionShaRevision %>_<%- arch %>.deb',
+        macos: '<%- bin %>-v<%- version %>-<%- sha %>-<%- arch %>.pkg',
+        manifest: '<%- bin %>-v<%- version %>-<%- sha %>-<%- platform %>-<%- arch %>-buildmanifest',
+        unversioned: '<%- bin %>-<%- platform %>-<%- arch %><%- ext %>',
+        versioned: '<%- bin %>-v<%- version %>-<%- sha %>-<%- platform %>-<%- arch %><%- ext %>',
+        win32: '<%- bin %>-v<%- version %>-<%- sha %>-<%- arch %>.exe',
+    };
+    return (0, ejs_1.render)(templates[type], { ...options });
+}
+function debArch(arch) {
+    if (arch === 'x64')
+        return 'amd64';
+    if (arch === 'x86')
+        return 'i386';
+    if (arch === 'arm')
+        return 'armel';
+    if (arch === 'arm64')
+        return 'arm64';
+    throw new Error(`invalid arch: ${arch}`);
+}
+function debVersion(buildConfig) {
+    return `${buildConfig.config.version.split('-')[0]}.${buildConfig.gitSha}-1`;
+    // see debian_revision: https://www.debian.org/doc/debian-policy/ch-controlfields.html
+}

package/lib/util.d.ts

@@ -0,0 +1,18 @@
+export declare function castArray<T>(input?: T | T[]): T[];
+export declare function uniqBy<T>(arr: T[], fn: (cur: T) => unknown): T[];
+export declare function compact<T>(a: (T | undefined)[]): T[];
+export declare function uniq<T>(arr: T[]): T[];
+type Types = boolean | number | string | undefined;
+export declare function sortBy<T>(arr: T[], fn: (i: T) => Types | Types[]): T[];
+interface VersionsObject {
+    [key: string]: string;
+}
+export declare const sortVersionsObjectByKeysDesc: (input: VersionsObject) => VersionsObject;
+export declare const prettifyPaths: (input: unknown) => string;
+export declare const hash: (algo: string, fp: string | string[]) => Promise<string>;
+export declare function checkFor7Zip(): Promise<void>;
+export declare function isEmpty(obj: Record<string, unknown>): boolean;
+export declare function validateBin(bin: string): boolean;
+export declare function isS3Compatible(endpoint: string | undefined): boolean;
+export declare function getS3ChecksumConfig(endpoint: string | undefined, envValue: string | undefined): string | undefined;
+export {};