@depup/oclif 4.22.92-depup.1

package/lib/commands/upload/macos.js

@@ -0,0 +1,92 @@
+"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 aws_1 = __importDefault(require("../../aws"));
+const log_1 = require("../../log");
+const Tarballs = __importStar(require("../../tarballs"));
+const upload_util_1 = require("../../upload-util");
+const util_1 = require("../../util");
+class UploadMacos extends core_1.Command {
+    static description = 'Upload macos installers built with `pack macos`.';
+    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,
+        }),
+        targets: core_1.Flags.string({
+            char: 't',
+            description: 'Comma-separated targets to upload (e.g.: darwin-x64,darwin-arm64).',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(UploadMacos);
+        const buildConfig = await Tarballs.buildConfig(flags.root, { sha: flags?.sha, targets: flags?.targets?.split(',') });
+        const { config, dist, s3Config } = buildConfig;
+        const S3Options = {
+            ACL: s3Config.acl || 'public-read',
+            Bucket: s3Config.bucket,
+        };
+        const cloudKeyBase = (0, upload_util_1.commitAWSDir)(config.version, buildConfig.gitSha, s3Config);
+        const upload = async (arch) => {
+            const templateKey = (0, upload_util_1.templateShortKey)('macos', {
+                arch,
+                bin: config.bin,
+                sha: buildConfig.gitSha,
+                version: config.version,
+            });
+            const cloudKey = `${cloudKeyBase}/${templateKey}`;
+            const localPkg = dist(`macos/${templateKey}`);
+            if (fs.existsSync(localPkg))
+                await aws_1.default.s3.uploadFile(localPkg, { ...S3Options, CacheControl: 'max-age=86400', Key: cloudKey }, {
+                    dryRun: flags['dry-run'],
+                });
+            else
+                this.error('Cannot find macOS pkg', {
+                    suggestions: ['Run "oclif pack macos" before uploading'],
+                });
+        };
+        const arches = (0, util_1.uniq)(buildConfig.targets.filter((t) => t.platform === 'darwin').map((t) => t.arch));
+        await Promise.all(arches.map((a) => upload(a)));
+        (0, log_1.log)(`done uploading macos pkgs for v${config.version}-${buildConfig.gitSha}`);
+    }
+}
+exports.default = UploadMacos;

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

@@ -0,0 +1,12 @@
+import { Command, Interfaces } from '@oclif/core';
+export default class UploadTarballs 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>;
+        xz: Interfaces.BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/upload/tarballs.js

@@ -0,0 +1,135 @@
+"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 aws_1 = __importDefault(require("../../aws"));
+const log_1 = require("../../log");
+const Tarballs = __importStar(require("../../tarballs"));
+const upload_util_1 = require("../../upload-util");
+class UploadTarballs extends core_1.Command {
+    static description = 'Upload an oclif CLI to S3.';
+    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,
+        }),
+        targets: core_1.Flags.string({ char: 't', description: 'Comma-separated targets to upload (e.g.: linux-arm,win32-x64).' }),
+        xz: core_1.Flags.boolean({ allowNo: true, description: 'Also upload xz.' }),
+    };
+    async run() {
+        const { flags } = await this.parse(UploadTarballs);
+        const buildConfig = await Tarballs.buildConfig(flags.root, {
+            sha: flags?.sha,
+            targets: flags?.targets?.split(','),
+            xz: flags.xz,
+        });
+        const { config, dist, s3Config, xz } = buildConfig;
+        // fail early if targets are not built
+        for (const target of buildConfig.targets) {
+            const tarball = dist((0, upload_util_1.templateShortKey)('versioned', {
+                bin: config.bin,
+                ext: '.tar.gz',
+                sha: buildConfig.gitSha,
+                version: config.version,
+                ...target,
+            }));
+            if (!fs.existsSync(tarball))
+                this.error(`Cannot find a tarball ${tarball} for ${target.platform}-${target.arch}`, {
+                    suggestions: [`Run "oclif pack --target ${target.platform}-${target.arch}" before uploading`],
+                });
+        }
+        const S3Options = {
+            ACL: s3Config.acl || 'public-read',
+            Bucket: s3Config.bucket,
+        };
+        const uploadTarball = async (options) => {
+            const shortKeyInputs = {
+                // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
+                arch: options?.arch,
+                bin: config.bin,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-asserted-optional-chain
+                platform: options?.platform,
+                sha: buildConfig.gitSha,
+                version: config.version,
+            };
+            const releaseTarballs = async (ext) => {
+                const localKey = (0, upload_util_1.templateShortKey)('versioned', { ...shortKeyInputs, ext });
+                const cloudKey = `${(0, upload_util_1.commitAWSDir)(config.version, buildConfig.gitSha, s3Config)}/${localKey}`;
+                await aws_1.default.s3.uploadFile(dist(localKey), {
+                    ...S3Options,
+                    CacheControl: 'max-age=604800',
+                    ContentType: 'application/gzip',
+                    Key: cloudKey,
+                }, {
+                    dryRun: flags['dry-run'],
+                });
+            };
+            const maybeUploadManifest = async () => {
+                const manifest = (0, upload_util_1.templateShortKey)('manifest', shortKeyInputs);
+                const cloudKey = `${(0, upload_util_1.commitAWSDir)(config.version, buildConfig.gitSha, s3Config)}/${manifest}`;
+                const local = dist(manifest);
+                (0, log_1.log)(`checking for buildmanifest at ${local}`);
+                if (fs.existsSync(local)) {
+                    (0, log_1.log)(`uploading buildmanifest ${manifest}`);
+                    return aws_1.default.s3.uploadFile(dist(manifest), {
+                        ...S3Options,
+                        CacheControl: 'max-age=86400',
+                        ContentType: 'application/json',
+                        Key: cloudKey,
+                    }, {
+                        dryRun: flags['dry-run'],
+                    });
+                }
+                core_1.ux.warn(`Cannot find buildmanifest ${local}. CLI will not be able to update itself.`);
+            };
+            await Promise.all([
+                releaseTarballs('.tar.gz'),
+                maybeUploadManifest(),
+                ...(xz ? [releaseTarballs('.tar.xz')] : []),
+            ]);
+        };
+        if (buildConfig.targets.length > 0)
+            (0, log_1.log)('uploading targets');
+        await Promise.all(buildConfig.targets.map((t) => uploadTarball(t)));
+        (0, log_1.log)(`done uploading tarballs & manifests for v${config.version}-${buildConfig.gitSha}`);
+    }
+}
+exports.default = UploadTarballs;

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

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class UploadWin 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>;
+        targets: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/lib/commands/upload/win.js

@@ -0,0 +1,97 @@
+"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 aws_1 = __importDefault(require("../../aws"));
+const log_1 = require("../../log");
+const Tarballs = __importStar(require("../../tarballs"));
+const upload_util_1 = require("../../upload-util");
+class UploadWin extends core_1.Command {
+    static description = 'Upload windows installers built with `pack win`.';
+    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,
+        }),
+        targets: core_1.Flags.string({ description: 'Comma-separated targets to pack (e.g.: win32-x64,win32-x86,win32-arm64).' }),
+    };
+    async run() {
+        const { flags } = await this.parse(UploadWin);
+        const buildConfig = await Tarballs.buildConfig(flags.root, { sha: flags?.sha, targets: flags?.targets?.split(',') });
+        const { config, dist, s3Config } = buildConfig;
+        const S3Options = {
+            ACL: s3Config.acl || 'public-read',
+            Bucket: s3Config.bucket,
+        };
+        const archs = buildConfig.targets.filter((t) => t.platform === 'win32').map((t) => t.arch);
+        for (const arch of archs) {
+            const templateKey = (0, upload_util_1.templateShortKey)('win32', {
+                arch,
+                bin: config.bin,
+                sha: buildConfig.gitSha,
+                version: config.version,
+            });
+            const localKey = dist(`win32/${templateKey}`);
+            if (!fs.existsSync(localKey))
+                this.error(`Cannot find Windows exe for ${arch}`, {
+                    suggestions: ['Run "oclif pack win" before uploading'],
+                });
+        }
+        const cloudKeyBase = (0, upload_util_1.commitAWSDir)(config.pjson.version, buildConfig.gitSha, s3Config);
+        const uploadWin = async (arch) => {
+            const templateKey = (0, upload_util_1.templateShortKey)('win32', {
+                arch,
+                bin: config.bin,
+                sha: buildConfig.gitSha,
+                version: config.version,
+            });
+            const localExe = dist(`win32/${templateKey}`);
+            const cloudKey = `${cloudKeyBase}/${templateKey}`;
+            if (fs.existsSync(localExe))
+                await aws_1.default.s3.uploadFile(localExe, { ...S3Options, CacheControl: 'max-age=86400', Key: cloudKey }, {
+                    dryRun: flags['dry-run'],
+                });
+        };
+        await Promise.all([uploadWin('x64'), uploadWin('x86'), uploadWin('arm64')]);
+        (0, log_1.log)(`done uploading windows executables for v${config.version}-${buildConfig.gitSha}`);
+    }
+}
+exports.default = UploadWin;

package/lib/generator.d.ts

@@ -0,0 +1,57 @@
+import { Command, Interfaces } from '@oclif/core';
+import { ExecOptions } from 'node:child_process';
+export type FlaggablePrompt = {
+    message: string;
+    options?: readonly string[] | string[];
+    validate: (d: string) => boolean | string;
+};
+export type FlagsOfPrompts<T extends Record<string, FlaggablePrompt>> = Record<keyof T, Interfaces.OptionFlag<string | undefined, Interfaces.CustomOptions>>;
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof GeneratorCommand)['baseFlags'] & T['flags']>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T['args']>;
+export type GetFlagOrPromptOptions = {
+    /**
+     * The default value for the prompt if the `--yes` flag is provided.
+     */
+    defaultValue: string;
+    /**
+     * A function that returns a value if the user has not provided the value via the flag. This will rerun before
+     * the check for the `--yes` flag.
+     */
+    maybeOtherValue?: () => Promise<string | undefined>;
+    /**
+     * The name of the flaggable prompt. Corresponds to the key in `this.flags`.
+     */
+    name: string;
+    /**
+     * The type of prompt to display.
+     */
+    type: 'input' | 'select';
+};
+export declare function exec(command: string, opts?: ExecOptions & {
+    silent?: boolean;
+}): Promise<{
+    stderr: string;
+    stdout: string;
+}>;
+export declare function readPJSON(location: string): Promise<(Interfaces.PJSON & {
+    scripts: Record<string, string>;
+}) | undefined>;
+export declare function makeFlags<T extends Record<string, FlaggablePrompt>>(flaggablePrompts: T): FlagsOfPrompts<T>;
+export declare abstract class GeneratorCommand<T extends typeof Command> extends Command {
+    protected args: Args<T>;
+    protected flaggablePrompts: Record<string, FlaggablePrompt>;
+    protected flags: Flags<T>;
+    templatesDir: string;
+    /**
+     * Get a flag value or prompt the user for a value.
+     *
+     * Resolution order:
+     * - Flag value provided by the user
+     * - Value returned by `maybeOtherValue`
+     * - `defaultValue` if the `--yes` flag is provided
+     * - Prompt the user for a value
+     */
+    getFlagOrPrompt({ defaultValue, maybeOtherValue, name, type }: GetFlagOrPromptOptions): Promise<string>;
+    init(): Promise<void>;
+    template(source: string, destination: string, data?: Record<string, unknown>): Promise<void>;
+}

package/lib/generator.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorCommand = void 0;
+exports.exec = exec;
+exports.readPJSON = readPJSON;
+exports.makeFlags = makeFlags;
+const core_1 = require("@oclif/core");
+const ansis_1 = __importDefault(require("ansis"));
+const ejs_1 = require("ejs");
+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 = require("node:path");
+const log_1 = require("./log");
+const debug = log_1.debug.new(`generator`);
+async function exec(command, opts) {
+    const silent = opts ? opts.silent : true;
+    return new Promise((resolve, reject) => {
+        if (!silent)
+            core_1.ux.stdout(ansis_1.default.dim(command));
+        const p = (0, node_child_process_1.exec)(command, opts ?? {}, (err, stdout, stderr) => {
+            if (err)
+                return reject(err);
+            resolve({ stderr, stdout });
+        });
+        if (!silent)
+            p.stdout?.pipe(process.stdout);
+        if (!silent)
+            p.stderr?.pipe(process.stderr);
+    });
+}
+async function readPJSON(location) {
+    try {
+        const packageJSON = await (0, promises_1.readFile)((0, node_path_1.join)(location, 'package.json'), 'utf8');
+        return JSON.parse(packageJSON);
+    }
+    catch { }
+}
+function validateInput(input, validate) {
+    const result = validate(input);
+    if (typeof result === 'string')
+        throw new Error(result);
+    return input;
+}
+function makeFlags(flaggablePrompts) {
+    return Object.fromEntries(Object.entries(flaggablePrompts).map(([key, value]) => [
+        key,
+        core_1.Flags.string({
+            description: `Supply answer for prompt: ${value.message}`,
+            options: value.options,
+            async parse(input) {
+                return validateInput(input, value.validate);
+            },
+        }),
+    ]));
+}
+class GeneratorCommand extends core_1.Command {
+    args;
+    flaggablePrompts;
+    flags;
+    templatesDir;
+    /**
+     * Get a flag value or prompt the user for a value.
+     *
+     * Resolution order:
+     * - Flag value provided by the user
+     * - Value returned by `maybeOtherValue`
+     * - `defaultValue` if the `--yes` flag is provided
+     * - Prompt the user for a value
+     */
+    async getFlagOrPrompt({ defaultValue, maybeOtherValue, name, type }) {
+        if (!this.flaggablePrompts)
+            throw new Error('No flaggable prompts defined');
+        if (!this.flaggablePrompts[name])
+            throw new Error(`No flaggable prompt defined for ${name}`);
+        const maybeFlag = () => {
+            if (this.flags[name]) {
+                this.log(`${ansis_1.default.green('?')} ${ansis_1.default.bold(this.flaggablePrompts[name].message)} ${ansis_1.default.cyan(this.flags[name])}`);
+                return this.flags[name];
+            }
+        };
+        const maybeDefault = () => {
+            if (this.flags.yes) {
+                this.log(`${ansis_1.default.green('?')} ${ansis_1.default.bold(this.flaggablePrompts[name].message)} ${ansis_1.default.cyan(defaultValue)}`);
+                return defaultValue;
+            }
+        };
+        const checkMaybeOtherValue = async () => {
+            if (!maybeOtherValue)
+                return;
+            const otherValue = await maybeOtherValue();
+            if (otherValue) {
+                this.log(`${ansis_1.default.green('?')} ${ansis_1.default.bold(this.flaggablePrompts[name].message)} ${ansis_1.default.cyan(otherValue)}`);
+                return otherValue;
+            }
+        };
+        switch (type) {
+            case 'input': {
+                return (maybeFlag() ??
+                    (await checkMaybeOtherValue()) ??
+                    maybeDefault() ??
+                    // Dynamic import because @inquirer/input is ESM only. Once oclif is ESM, we can make this a normal import
+                    // so that we can avoid importing on every single question.
+                    (await import('@inquirer/input')).default({
+                        default: defaultValue,
+                        message: this.flaggablePrompts[name].message,
+                        validate: this.flaggablePrompts[name].validate,
+                    }));
+            }
+            case 'select': {
+                return (maybeFlag() ??
+                    (await checkMaybeOtherValue()) ??
+                    maybeDefault() ??
+                    // Dynamic import because @inquirer/select is ESM only. Once oclif is ESM, we can make this a normal import
+                    // so that we can avoid importing on every single question.
+                    (await import('@inquirer/select')).default({
+                        choices: (this.flaggablePrompts[name].options ?? []).map((o) => ({ name: o, value: o })),
+                        default: defaultValue,
+                        message: this.flaggablePrompts[name].message,
+                    }));
+            }
+            default: {
+                throw new Error('Invalid type');
+            }
+        }
+    }
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            args: this.ctor.args,
+            baseFlags: super.ctor.baseFlags,
+            enableJsonFlag: this.ctor.enableJsonFlag,
+            flags: this.ctor.flags,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.args = args;
+        // @ts-expect-error because we trust that child classes will set this - also, it's okay if they don't
+        this.flaggablePrompts = this.ctor.flaggablePrompts ?? {};
+        this.templatesDir = (0, node_path_1.join)(__dirname, '../templates');
+        debug(`Templates directory: ${this.templatesDir}`);
+    }
+    async template(source, destination, data) {
+        if (this.flags['dry-run']) {
+            debug('[DRY RUN] Rendering template %s to %s', source, destination);
+        }
+        else {
+            debug('Rendering template %s to %s', source, destination);
+        }
+        const rendered = await new Promise((resolve, reject) => {
+            (0, ejs_1.renderFile)(source, data ?? {}, (err, str) => {
+                if (err)
+                    reject(err);
+                return resolve(str);
+            });
+        });
+        let verb = 'Creating';
+        if (rendered) {
+            const relativePath = (0, node_path_1.relative)(process.cwd(), destination);
+            if ((0, node_fs_1.existsSync)(destination)) {
+                const confirmation = this.flags.force ??
+                    (await (await import('@inquirer/confirm')).default({
+                        message: `Overwrite ${relativePath}?`,
+                    }));
+                if (confirmation) {
+                    verb = 'Overwriting';
+                }
+                else {
+                    this.log(`${ansis_1.default.yellow('Skipping')} ${relativePath}`);
+                    return;
+                }
+            }
+            this.log(`${ansis_1.default.yellow(verb)} ${relativePath}`);
+            if (!this.flags['dry-run']) {
+                await (0, fs_extra_1.outputFile)(destination, rendered);
+            }
+        }
+    }
+}
+exports.GeneratorCommand = GeneratorCommand;

package/lib/help-compatibility.d.ts

@@ -0,0 +1,11 @@
+import { Command, HelpBase } from '@oclif/core';
+interface MaybeCompatibleHelp extends HelpBase {
+    command?: (command: Command.Cached) => string;
+    formatCommand?: (command: Command.Cached) => string;
+}
+export declare class HelpCompatibilityWrapper {
+    inner: MaybeCompatibleHelp;
+    constructor(inner: MaybeCompatibleHelp);
+    formatCommand(command: Command.Cached): string;
+}
+export {};

package/lib/help-compatibility.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HelpCompatibilityWrapper = void 0;
+class IncompatibleHelpError extends Error {
+    message = 'Please implement `formatCommand` in your custom help class.\nSee https://oclif.io/docs/help_classes for more.';
+}
+class HelpCompatibilityWrapper {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    formatCommand(command) {
+        if (this.inner.formatCommand) {
+            return this.inner.formatCommand(command);
+        }
+        if (this.inner.command) {
+            return command.description + '\n\n' + this.inner.command(command);
+        }
+        throw new IncompatibleHelpError();
+    }
+}
+exports.HelpCompatibilityWrapper = HelpCompatibilityWrapper;

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/lib/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/lib/log.d.ts

@@ -0,0 +1,2 @@
+export declare const debug: any;
+export declare function log(format: string, ...args: unknown[]): void;

package/lib/log.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = void 0;
+exports.log = log;
+const core_1 = require("@oclif/core");
+const node_util_1 = require("node:util");
+const util_1 = require("./util");
+exports.debug = require('debug')('oclif');
+exports.debug.new = (name) => require('debug')(`oclif:${name}`);
+function log(format, ...args) {
+    args = args.map((arg) => (0, util_1.prettifyPaths)(arg));
+    return exports.debug.enabled ? (0, exports.debug)(format, ...args) : core_1.ux.stdout(`oclif: ${(0, node_util_1.format)(format, ...args)}`);
+}