@hyperdrive.bot/cli 1.0.6 → 1.0.8

package/dist/utils/hook-flow.js

@@ -0,0 +1,154 @@
+import inquirer from 'inquirer';
+/**
+ * Prompt user to select a trigger status from available Jira statuses
+ */
+export async function promptTriggerStatus(statuses) {
+    const choices = [
+        { name: '* (any status)', value: '*' },
+        ...statuses.map(s => ({ name: s, value: s })),
+    ];
+    const { triggerStatus } = await inquirer.prompt([{
+            choices,
+            message: 'Select trigger status:',
+            name: 'triggerStatus',
+            type: 'list',
+        }]);
+    return triggerStatus;
+}
+/**
+ * Prompt user to select an action type
+ */
+export async function promptActionType() {
+    const { actionType } = await inquirer.prompt([{
+            choices: [
+                { name: 'Slack notification', value: 'slack-notify' },
+                { name: 'ADHB enrichment', value: 'adhb-enrich' },
+                { name: 'Webhook', value: 'webhook' },
+                { name: 'CI trigger', value: 'ci-trigger' },
+            ],
+            message: 'Select action type:',
+            name: 'actionType',
+            type: 'list',
+        }]);
+    return actionType;
+}
+/**
+ * Prompt for action-specific configuration based on action type
+ */
+export async function promptActionConfig(actionType) {
+    switch (actionType) {
+        case 'slack-notify': {
+            const answers = await inquirer.prompt([
+                {
+                    message: 'Slack channel (e.g. #deploys):',
+                    name: 'channel',
+                    type: 'input',
+                    validate: (input) => input.trim() ? true : 'Channel is required',
+                },
+                {
+                    default: '',
+                    message: 'Message template (optional):',
+                    name: 'template',
+                    type: 'input',
+                },
+            ]);
+            const config = { channel: answers.channel };
+            if (answers.template)
+                config.template = answers.template;
+            return config;
+        }
+        case 'adhb-enrich': {
+            const { priority } = await inquirer.prompt([{
+                    choices: [
+                        { name: 'high', value: 'high' },
+                        { name: 'normal', value: 'normal' },
+                        { name: 'low', value: 'low' },
+                    ],
+                    default: 'normal',
+                    message: 'Priority:',
+                    name: 'priority',
+                    type: 'list',
+                }]);
+            return { priority };
+        }
+        case 'webhook': {
+            const answers = await inquirer.prompt([
+                {
+                    message: 'Webhook URL:',
+                    name: 'url',
+                    type: 'input',
+                    validate: (input) => input.trim().startsWith('http') ? true : 'Valid URL is required',
+                },
+                {
+                    choices: [
+                        { name: 'POST', value: 'POST' },
+                        { name: 'PUT', value: 'PUT' },
+                    ],
+                    default: 'POST',
+                    message: 'HTTP method:',
+                    name: 'method',
+                    type: 'list',
+                },
+            ]);
+            return { method: answers.method, url: answers.url };
+        }
+        case 'ci-trigger': {
+            const answers = await inquirer.prompt([
+                {
+                    choices: [
+                        { name: 'GitHub', value: 'github' },
+                        { name: 'GitLab', value: 'gitlab' },
+                    ],
+                    message: 'Provider:',
+                    name: 'provider',
+                    type: 'list',
+                },
+                {
+                    message: 'Pipeline identifier:',
+                    name: 'pipeline',
+                    type: 'input',
+                    validate: (input) => input.trim() ? true : 'Pipeline identifier is required',
+                },
+                {
+                    default: '',
+                    message: 'Git ref (optional):',
+                    name: 'ref',
+                    type: 'input',
+                },
+            ]);
+            const config = { pipeline: answers.pipeline, provider: answers.provider };
+            if (answers.ref)
+                config.ref = answers.ref;
+            return config;
+        }
+        default:
+            throw new Error(`Unknown action type: ${actionType}`);
+    }
+}
+/**
+ * Prompt user to select a hook from a list
+ */
+export async function promptSelectHook(hooks) {
+    const { selectedHook } = await inquirer.prompt([{
+            choices: hooks.map(h => ({
+                name: `[${h.triggerStatus}] ${h.actionType} (${h.enabled ? 'enabled' : 'disabled'})`,
+                value: h,
+            })),
+            message: 'Select a hook:',
+            name: 'selectedHook',
+            type: 'list',
+        }]);
+    return selectedHook;
+}
+/**
+ * Prompt user to confirm hook deletion
+ */
+export async function promptConfirmDelete(hook) {
+    const { confirmed } = await inquirer.prompt([{
+            default: false,
+            message: `Delete hook [${hook.triggerStatus}] ${hook.actionType}?`,
+            name: 'confirmed',
+            type: 'confirm',
+        }]);
+    return confirmed;
+}

package/dist/utils/jira-flow.d.ts

@@ -59,7 +59,7 @@ export declare function promptJiraConnect(includeSkip?: boolean): Promise<'skip'
  * This function is separated from user input collection to allow
  * proper spinner timing and better separation of concerns.
  */
-export declare function registerJiraDomain(jiraDomain: string): Promise<JiraConnectResult>;
+export declare function registerJiraDomain(jiraDomain: string, tenantDomain?: string): Promise<JiraConnectResult>;
 /**
  * Execute the Jira connect flow
  *
@@ -68,4 +68,4 @@ export declare function registerJiraDomain(jiraDomain: string): Promise<JiraConn
  * 2. Pre-registering the domain with Hyperdrive API
  * 3. Returning result with marketplace URL
  */
-export declare function executeJiraConnect(): Promise<JiraConnectResult>;
+export declare function executeJiraConnect(tenantDomain?: string): Promise<JiraConnectResult>;

package/dist/utils/jira-flow.js

@@ -75,9 +75,9 @@ export async function promptJiraConnect(includeSkip = false) {
  * This function is separated from user input collection to allow
  * proper spinner timing and better separation of concerns.
  */
-export async function registerJiraDomain(jiraDomain) {
+export async function registerJiraDomain(jiraDomain, tenantDomain) {
     try {
-        const service = new HyperdriveSigV4Service();
+        const service = new HyperdriveSigV4Service(tenantDomain);
         // Use the public API method instead of accessing private method
         const response = await service.jiraPreRegister({ jiraDomain });
         return {
@@ -103,12 +103,12 @@ export async function registerJiraDomain(jiraDomain) {
  * 2. Pre-registering the domain with Hyperdrive API
  * 3. Returning result with marketplace URL
  */
-export async function executeJiraConnect() {
+export async function executeJiraConnect(tenantDomain) {
     try {
         // Step 1: Prompt for Jira domain (no spinner - user needs to see prompts)
         const domainData = await promptJiraDomain();
         // Step 2: Register domain with API (caller should wrap this with spinner)
-        return await registerJiraDomain(domainData.jiraDomain);
+        return await registerJiraDomain(domainData.jiraDomain, tenantDomain);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/utils/table.d.ts

@@ -0,0 +1,17 @@
+interface ColumnConfig<T> {
+    header: string;
+    minWidth?: number;
+    get?: (row: T) => string;
+}
+type TableColumns<T> = Record<string, ColumnConfig<T>>;
+/**
+ * Print data in a table format using cli-table3
+ * Replacement for oclif's deprecated ux.table
+ */
+export declare function printTable<T extends Record<string, unknown>>(data: T[], columns: TableColumns<T>, logger: (msg: string) => void): void;
+/**
+ * Print a styled header
+ * Replacement for oclif's deprecated ux.styledHeader
+ */
+export declare function printHeader(text: string, logger: (msg: string) => void): void;
+export {};

package/dist/utils/table.js

@@ -0,0 +1,41 @@
+import Table from 'cli-table3';
+import chalk from 'chalk';
+/**
+ * Print data in a table format using cli-table3
+ * Replacement for oclif's deprecated ux.table
+ */
+export function printTable(data, columns, logger) {
+    const columnKeys = Object.keys(columns);
+    const headers = columnKeys.map(key => chalk.bold(columns[key].header));
+    const colWidths = columnKeys.map(key => columns[key].minWidth ?? null);
+    const hasColWidths = colWidths.some(w => w !== null);
+    const tableOptions = {
+        head: headers,
+        style: { head: [], border: [] },
+    };
+    if (hasColWidths) {
+        tableOptions.colWidths = colWidths;
+    }
+    const table = new Table(tableOptions);
+    for (const row of data) {
+        const rowData = columnKeys.map(key => {
+            const col = columns[key];
+            if (col.get) {
+                return col.get(row);
+            }
+            const value = row[key];
+            return value !== undefined && value !== null ? String(value) : '';
+        });
+        table.push(rowData);
+    }
+    logger(table.toString());
+}
+/**
+ * Print a styled header
+ * Replacement for oclif's deprecated ux.styledHeader
+ */
+export function printHeader(text, logger) {
+    logger('');
+    logger(chalk.bold(text));
+    logger(chalk.gray('─'.repeat(Math.min(text.length + 10, 60))));
+}