@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/commands/{jira → tracker}/hook/toggle.js

@@ -3,15 +3,16 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
 import { promptSelectHook } from '../../../utils/hook-flow.js';
+import { normalizeHookToV2 } from '../../../utils/hook-normalize.js';
 export default class HookToggle extends Command {
     static args = {
-        project: Args.string({ description: 'Hyperdrive project ID or slug', required: true }),
+        project: Args.string({ description: 'Tracker project ID', required: true }),
     };
-    static description = 'Toggle the enabled state of a status transition hook';
+    static description = 'Toggle the enabled state of an automation hook';
     static examples = [
-        '<%= config.bin %> jira hook toggle my-project',
-        '<%= config.bin %> jira hook toggle my-project --hook-id hook-123',
-        '<%= config.bin %> jira hook toggle my-project --hook-id hook-123 --json',
+        '<%= config.bin %> tracker hook toggle my-project',
+        '<%= config.bin %> tracker hook toggle my-project --hook-id hook-123',
+        '<%= config.bin %> tracker hook toggle my-project --hook-id hook-123 --json',
     ];
     static flags = {
         domain: Flags.string({
@@ -53,8 +54,8 @@ export default class HookToggle extends Command {
             // Fetch hooks for interactive selection
             const fetchSpinner = ora('Fetching hooks...').start();
             try {
-                const response = await apiService.hookList(args.project);
-                const hooks = response.hooks;
+                const response = await apiService.trackerProjectHookList(args.project);
+                const hooks = (Array.isArray(response) ? response : response.hooks).map(normalizeHookToV2);
                 fetchSpinner.succeed(`Found ${hooks.length} hook${hooks.length === 1 ? '' : 's'}`);
                 if (hooks.length === 0) {
                     this.log('');
@@ -80,8 +81,9 @@ export default class HookToggle extends Command {
             // If we don't know the current state (non-interactive with --hook-id), fetch it first
             let enabled;
             if (newEnabled === undefined) {
-                const response = await apiService.hookList(args.project);
-                const hook = response.hooks.find(h => h.hookId === hookId);
+                const response = await apiService.trackerProjectHookList(args.project);
+                const toggleHooks = (Array.isArray(response) ? response : response.hooks).map(normalizeHookToV2);
+                const hook = toggleHooks.find(h => h.hookId === hookId);
                 if (!hook) {
                     toggleSpinner?.fail('Hook not found');
                     this.error(`Hook ${hookId} not found in project ${args.project}`);
@@ -91,7 +93,7 @@ export default class HookToggle extends Command {
             else {
                 enabled = newEnabled;
             }
-            const updatedHook = await apiService.hookUpdate(args.project, hookId, { enabled });
+            const updatedHook = await apiService.trackerProjectHookUpdate(args.project, hookId, { enabled });
             toggleSpinner?.succeed('Hook toggled');
             if (isJson) {
                 this.log(JSON.stringify(updatedHook, null, 2));
@@ -100,8 +102,8 @@ export default class HookToggle extends Command {
             this.log('');
             this.log(chalk.green('✅ Hook updated'));
             this.log(`  Hook ID:        ${chalk.cyan(updatedHook.hookId)}`);
-            this.log(`  Trigger Status: ${chalk.cyan(updatedHook.triggerStatus)}`);
-            this.log(`  Action Type:    ${chalk.cyan(updatedHook.actionType)}`);
+            this.log(`  Trigger Event:  ${chalk.cyan(updatedHook.trigger?.event ?? '')}`);
+            this.log(`  Action Type:    ${chalk.cyan(updatedHook.action?.type ?? '')}`);
             this.log(`  Enabled:        ${updatedHook.enabled ? chalk.green('enabled') : chalk.red('disabled')}`);
             this.log('');
         }

package/dist/commands/tracker/project/init.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class TrackerProjectInit extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        modules: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'primary-module': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'project-name': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'tracker-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tracker/project/init.js

@@ -0,0 +1,178 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+import { displaySummary, executeTrackerProjectInit, parseConfigFile, stepConfirm, stepLinkModules, stepMapStatuses, stepSelectExternalProject, stepSelectTracker, } from '../../../utils/tracker-project-flow.js';
+export default class TrackerProjectInit extends Command {
+    static description = 'Initialize a tracker project with module linking, status mapping, and hooks';
+    static examples = [
+        '<%= config.bin %> tracker project init',
+        '<%= config.bin %> tracker project init --domain my-tenant.hyperdrivebot.dev',
+        '<%= config.bin %> tracker project init --json',
+        '<%= config.bin %> tracker project init --tracker-id abc123 --project-key PROJ --project-name "My Project" --modules mod1,mod2 --primary-module mod1 --config ./tracker-init.json --yes',
+    ];
+    static flags = {
+        config: Flags.string({
+            description: 'Path to JSON config file with statusMapping and hooks',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            description: 'Output result as JSON',
+        }),
+        modules: Flags.string({
+            description: 'Comma-separated module IDs to link',
+        }),
+        'primary-module': Flags.string({
+            description: 'Primary module ID (from --modules list)',
+        }),
+        'project-key': Flags.string({
+            description: 'External project key (e.g., PROJ)',
+        }),
+        'project-name': Flags.string({
+            description: 'External project name',
+        }),
+        'tracker-id': Flags.string({
+            description: 'Tracker connection ID (skips interactive selection)',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompt',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TrackerProjectInit);
+        const isJson = flags.json;
+        const skipConfirm = flags.yes;
+        if (!isJson) {
+            this.log('');
+            this.log(chalk.blue.bold('🔗 Tracker Project Init Wizard'));
+            this.log('');
+            this.log(chalk.dim('This wizard will create a tracker project, link modules,'));
+            this.log(chalk.dim('map statuses, and optionally configure hooks.'));
+            this.log('');
+        }
+        // Auth check
+        let service;
+        const spinner = isJson ? null : ora('Checking authentication...').start();
+        try {
+            service = new HyperdriveSigV4Service(flags.domain);
+            spinner?.succeed('Authenticated');
+        }
+        catch (error) {
+            spinner?.fail('Not authenticated');
+            this.error(`${error.message}\n\n` +
+                `Please authenticate first with: ${chalk.cyan('hd auth login')}`);
+        }
+        // Parse config file if provided
+        let configFileData;
+        if (flags.config) {
+            try {
+                configFileData = parseConfigFile(flags.config);
+            }
+            catch (error) {
+                this.error(error.message);
+            }
+        }
+        try {
+            // Step (a): Select tracker
+            if (!isJson && !flags['tracker-id']) {
+                this.log('');
+                this.log(chalk.blue('Step 1: Select Tracker'));
+                this.log(chalk.dim('Choose a connected tracker instance'));
+                this.log('');
+            }
+            const tracker = await stepSelectTracker(service, flags['tracker-id']);
+            // Step (b): Select external project
+            const projectOverride = flags['project-key']
+                ? { projectKey: flags['project-key'], projectName: flags['project-name'] || flags['project-key'] }
+                : undefined;
+            if (!isJson && !projectOverride) {
+                this.log('');
+                this.log(chalk.blue('Step 2: Select External Project'));
+                this.log(chalk.dim('Choose the project from your tracker'));
+                this.log('');
+            }
+            const externalProject = await stepSelectExternalProject(service, tracker.trackerId, projectOverride);
+            // Step (c): Link modules
+            const modulesOverride = flags.modules
+                ? { moduleIds: flags.modules.split(',').map(s => s.trim()), primaryModuleId: flags['primary-module'] }
+                : undefined;
+            if (!isJson && !modulesOverride) {
+                this.log('');
+                this.log(chalk.blue('Step 3: Link Modules'));
+                this.log(chalk.dim('Select Hyperdrive modules to link'));
+                this.log('');
+            }
+            const linkedModules = await stepLinkModules(service, modulesOverride);
+            // Step (d): Map statuses + configure hooks
+            if (!isJson && !configFileData) {
+                this.log('');
+                this.log(chalk.blue('Step 4: Map Statuses & Configure Hooks'));
+                this.log(chalk.dim('Map provider statuses to normalized workflow states'));
+                this.log('');
+            }
+            const { hooks, statusMapping } = await stepMapStatuses(service, tracker.trackerId, externalProject.externalProjectKey, configFileData);
+            const config = {
+                externalProject,
+                hooks,
+                linkedModules,
+                statusMapping,
+                tracker,
+            };
+            // Step (e): Confirm and save
+            if (!isJson && !skipConfirm) {
+                displaySummary(config, this.log.bind(this));
+                const confirmed = await stepConfirm();
+                if (!confirmed) {
+                    this.log(chalk.yellow('Setup cancelled. No changes were made.'));
+                    return;
+                }
+            }
+            // Execute
+            const result = await executeTrackerProjectInit(service, config, { nonInteractive: skipConfirm });
+            if (isJson) {
+                this.log(JSON.stringify({
+                    hooks: result.hooks,
+                    moduleLinks: result.moduleLinks,
+                    trackerProject: result.trackerProject,
+                }, null, 2));
+                return;
+            }
+            this.log('');
+            this.log(chalk.green('Tracker project initialized successfully!'));
+            this.log('');
+            this.log(`  Project ID:       ${chalk.cyan(result.trackerProject.trackerProjectId)}`);
+            this.log(`  Provider:         ${chalk.cyan(result.trackerProject.provider)}`);
+            this.log(`  External Project: ${chalk.cyan(result.trackerProject.externalProjectKey)}`);
+            this.log(`  Modules Linked:   ${chalk.cyan(String(result.moduleLinks.length))}`);
+            this.log(`  Hooks Created:    ${chalk.cyan(String(result.hooks.length))}`);
+            this.log('');
+            this.log(chalk.dim('Next steps:'));
+            this.log(`  ${chalk.cyan('hd tracker project list')}  — View tracker projects`);
+            this.log('');
+        }
+        catch (error) {
+            let errorMessage = error.message;
+            if (error.response) {
+                const status = error.response.status;
+                const data = error.response.data;
+                if (status === 401) {
+                    errorMessage = 'Authentication failed — please run "hd auth login"';
+                }
+                else if (status === 403) {
+                    errorMessage = 'Access denied — check your permissions';
+                }
+                else if (data?.error) {
+                    errorMessage = data.error;
+                }
+                else if (data?.message) {
+                    errorMessage = data.message;
+                }
+            }
+            this.error(errorMessage);
+        }
+    }
+}

package/dist/commands/tracker/project/link-module.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class TrackerProjectLinkModule extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        modules: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'primary-module': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'tracker-project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private executeLinking;
+    private promptModuleSelection;
+    private resolveNonInteractiveModules;
+}

package/dist/commands/tracker/project/link-module.js

@@ -0,0 +1,287 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../../utils/table.js';
+import { selectTrackerProject } from '../../../utils/tracker-project-flow.js';
+export default class TrackerProjectLinkModule extends Command {
+    static description = 'Link one or more modules to an existing tracker project';
+    static examples = [
+        '<%= config.bin %> tracker project link-module',
+        '<%= config.bin %> tracker project link-module --tracker-project-id abc123',
+        '<%= config.bin %> tracker project link-module --tracker-project-id abc123 --modules mod1,mod2 --primary-module mod1 --yes',
+        '<%= config.bin %> tracker project link-module --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Tenant domain (for multi-domain setups)',
+        }),
+        json: Flags.boolean({
+            default: false,
+            description: 'Output raw JSON response',
+        }),
+        modules: Flags.string({
+            description: 'Comma-separated module IDs to link (non-interactive)',
+        }),
+        'primary-module': Flags.string({
+            description: 'Module ID to designate as primary',
+        }),
+        'tracker-project-id': Flags.string({
+            description: 'Tracker project ID (skips interactive selection)',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            default: false,
+            description: 'Skip confirmation prompt',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(TrackerProjectLinkModule);
+        const isJson = flags.json;
+        const isNonInteractive = Boolean(flags.modules);
+        // Auth
+        let service;
+        const authSpinner = isJson ? null : ora('Checking authentication...').start();
+        try {
+            service = new HyperdriveSigV4Service(flags.domain);
+            authSpinner?.succeed('Authenticated');
+        }
+        catch (error) {
+            authSpinner?.fail('Not authenticated');
+            this.error(`${error.message}\n\n` +
+                `Please authenticate first with: ${chalk.cyan('hd auth login')}`);
+        }
+        try {
+            // Step 1: Select tracker project
+            const project = await selectTrackerProject(service, flags['tracker-project-id']);
+            if (!isJson) {
+                this.log(`\nTracker project: ${chalk.cyan(project.externalProjectKey)} — ${project.externalProjectName}\n`);
+            }
+            // Step 2: Fetch linked modules and all available modules
+            const fetchSpinner = isJson ? null : ora('Fetching modules...').start();
+            const [linkedModules, allModules] = await Promise.all([
+                service.trackerProjectListModules(project.trackerProjectId),
+                service.moduleList(),
+            ]);
+            fetchSpinner?.succeed(`Found ${allModules.length} module(s), ${linkedModules.length} already linked`);
+            // Build set of already-linked module IDs
+            const linkedIds = new Set(linkedModules.map(m => m.moduleId));
+            // Filter available (unlinked) modules
+            const availableModules = allModules.filter(m => !linkedIds.has(m.projectId || ''));
+            if (availableModules.length === 0) {
+                if (isJson) {
+                    this.log(JSON.stringify({ message: 'All modules are already linked to this tracker project.', results: [] }, null, 2));
+                }
+                else {
+                    this.log(chalk.yellow('\nAll modules are already linked to this tracker project.'));
+                    this.log(chalk.gray(`Use ${chalk.cyan('hd tracker project list-modules')} to see linked modules.`));
+                }
+                return;
+            }
+            // Step 3: Select modules to link
+            let modulesToLink;
+            if (isNonInteractive) {
+                modulesToLink = this.resolveNonInteractiveModules(flags, allModules, linkedIds);
+            }
+            else {
+                modulesToLink = await this.promptModuleSelection(availableModules);
+            }
+            if (modulesToLink.length === 0) {
+                this.log(chalk.yellow('\nNo modules to link.'));
+                return;
+            }
+            // Step 4: Display hooks info banner (not in JSON mode)
+            if (!isJson) {
+                this.log('');
+                this.log(chalk.blue('ℹ  Hooks configured on this tracker project apply to ALL linked modules.'));
+                this.log(chalk.blue('   Linking a new module means existing hooks (git-create-branch, webhooks, etc.)'));
+                this.log(chalk.blue('   will fire for that module\'s issues too.'));
+                this.log('');
+                // Display summary
+                this.log(chalk.bold('Modules to link:'));
+                for (const mod of modulesToLink) {
+                    const roleTag = mod.role === 'primary' ? chalk.green(' [primary]') : chalk.dim(' [supporting]');
+                    this.log(`  - ${mod.moduleName}${roleTag}`);
+                }
+                this.log('');
+            }
+            // Step 5: Confirmation
+            if (!flags.yes && !isNonInteractive && !isJson) {
+                const { confirmed } = await inquirer.prompt([{
+                        default: true,
+                        message: 'Link these modules?',
+                        name: 'confirmed',
+                        type: 'confirm',
+                    }]);
+                if (!confirmed) {
+                    this.log(chalk.yellow('Cancelled. No modules were linked.'));
+                    return;
+                }
+            }
+            // Step 6: Execute linking
+            const results = await this.executeLinking(service, project.trackerProjectId, modulesToLink, isJson);
+            // Step 7: Output results
+            if (isJson) {
+                this.log(JSON.stringify(results, null, 2));
+                return;
+            }
+            const linked = results.filter(r => r.status === 'linked');
+            const skipped = results.filter(r => r.status === 'skipped');
+            if (linked.length > 0) {
+                this.log('');
+                printTable(linked, {
+                    moduleName: {
+                        header: 'Module',
+                        minWidth: 20,
+                    },
+                    role: {
+                        get: (row) => {
+                            const r = row;
+                            return r.role === 'primary' ? chalk.green(r.role) : chalk.dim(r.role);
+                        },
+                        header: 'Role',
+                        minWidth: 14,
+                    },
+                    status: {
+                        get: () => chalk.green('linked'),
+                        header: 'Status',
+                    },
+                }, (msg) => this.log(msg));
+            }
+            this.log('');
+            this.log(chalk.green(`${linked.length} module(s) linked successfully.`));
+            if (skipped.length > 0) {
+                this.log(chalk.yellow(`${skipped.length} module(s) skipped (already linked or not found).`));
+            }
+            this.log('');
+        }
+        catch (error) {
+            let errorMessage = error.message;
+            if (error.response) {
+                const data = error.response.data;
+                if (error.response.status === 401) {
+                    errorMessage = 'Authentication failed — please run "hd auth login"';
+                }
+                else if (data?.error) {
+                    errorMessage = data.error;
+                }
+                else if (data?.message) {
+                    errorMessage = data.message;
+                }
+            }
+            this.error(errorMessage);
+        }
+    }
+    async executeLinking(service, trackerProjectId, modules, isJson) {
+        const results = [];
+        for (const mod of modules) {
+            const spinner = isJson ? null : ora(`Linking ${chalk.cyan(mod.moduleName)}...`).start();
+            try {
+                await service.trackerProjectLinkModule(trackerProjectId, {
+                    moduleId: mod.moduleId,
+                    role: mod.role,
+                });
+                spinner?.succeed(`Module ${chalk.cyan(mod.moduleName)} linked`);
+                results.push({
+                    moduleId: mod.moduleId,
+                    moduleName: mod.moduleName,
+                    role: mod.role,
+                    status: 'linked',
+                });
+            }
+            catch (error) {
+                const status = error.response?.status;
+                if (status === 409) {
+                    spinner?.warn(`Module ${chalk.cyan(mod.moduleName)} is already linked — skipping`);
+                    this.warn(`Module "${mod.moduleName}" is already linked — skipping`);
+                    results.push({
+                        moduleId: mod.moduleId,
+                        moduleName: mod.moduleName,
+                        role: mod.role,
+                        status: 'skipped',
+                        warning: 'Already linked',
+                    });
+                }
+                else {
+                    const msg = error.response?.data?.message || error.response?.data?.error || error.message;
+                    spinner?.warn(`Failed to link ${chalk.cyan(mod.moduleName)}: ${msg}`);
+                    this.warn(`Failed to link "${mod.moduleName}": ${msg}`);
+                    results.push({
+                        moduleId: mod.moduleId,
+                        moduleName: mod.moduleName,
+                        role: mod.role,
+                        status: 'skipped',
+                        warning: msg,
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    async promptModuleSelection(availableModules) {
+        const { selectedModules } = await inquirer.prompt([{
+                choices: availableModules.map(m => ({
+                    name: `${m.name || m.slug} (${chalk.dim(m.slug)})`,
+                    value: { moduleId: m.projectId || m.slug || '', moduleName: m.name || m.slug || '' },
+                })),
+                message: 'Select modules to link (space to select, enter to confirm):',
+                name: 'selectedModules',
+                type: 'checkbox',
+                validate: (input) => input.length > 0 ? true : 'Select at least one module',
+            }]);
+        const selected = selectedModules;
+        // Ask which is primary if more than one selected
+        let primaryId = null;
+        if (selected.length > 1) {
+            const { primary } = await inquirer.prompt([{
+                    choices: [
+                        ...selected.map(m => ({ name: m.moduleName, value: m.moduleId })),
+                        { name: chalk.dim('None — all supporting'), value: '__none__' },
+                    ],
+                    message: 'Which module is the primary module?',
+                    name: 'primary',
+                    type: 'list',
+                }]);
+            if (primary !== '__none__')
+                primaryId = primary;
+        }
+        else {
+            primaryId = selected[0].moduleId;
+        }
+        return selected.map(m => ({
+            moduleId: m.moduleId,
+            moduleName: m.moduleName,
+            role: m.moduleId === primaryId ? 'primary' : 'supporting',
+        }));
+    }
+    resolveNonInteractiveModules(flags, allModules, linkedIds) {
+        const moduleIds = flags.modules.split(',').map(s => s.trim()).filter(Boolean);
+        const primaryModuleId = flags['primary-module'];
+        const result = [];
+        for (const id of moduleIds) {
+            const mod = allModules.find(m => m.projectId === id || m.slug === id);
+            if (!mod) {
+                this.warn(`Module "${id}" not found — skipping`);
+                continue;
+            }
+            const moduleId = mod.projectId || mod.slug || '';
+            if (linkedIds.has(moduleId)) {
+                this.warn(`Module "${mod.name || mod.slug}" is already linked — skipping`);
+                continue;
+            }
+            const isPrimary = primaryModuleId && (moduleId === primaryModuleId || mod.slug === primaryModuleId);
+            result.push({
+                moduleId,
+                moduleName: mod.name || mod.slug || '',
+                role: isPrimary ? 'primary' : 'supporting',
+            });
+        }
+        // If only one module and no explicit primary, make it primary
+        if (result.length === 1 && !primaryModuleId) {
+            result[0].role = 'primary';
+        }
+        return result;
+    }
+}

package/dist/commands/tracker/project/list-modules.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class TrackerProjectListModules extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'tracker-project-id': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}