@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/commands/hook/add.js

@@ -0,0 +1,299 @@
+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 { promptLifecycleEvent, promptLifecycleConditions, promptActionTypeV2, promptActionConfig, promptOrder, promptTriggerType, promptCronExpression, promptCronTimezone, promptFlexibleWindow, getActionCategory, VALID_LIFECYCLE_EVENTS, } from '../../utils/hook-flow.js';
+export default class HookAdd extends Command {
+    static description = 'Create a tenant lifecycle hook or cron-triggered hook';
+    static examples = [
+        '<%= config.bin %> hook add',
+        '<%= config.bin %> hook add --event deploy.completed --action-type slack-notify --action-config \'{"channel":"C0ABC"}\'',
+        '<%= config.bin %> hook add --cron "0 3 * * ? *" --timezone "America/Sao_Paulo" --action-type webhook --action-config \'{"url":"https://example.com/hook","method":"POST"}\'',
+        '<%= config.bin %> hook add --cron "rate(1 hour)" --action-type slack-notify --action-config \'{"channel":"C0ABC"}\'',
+    ];
+    static flags = {
+        'action-config': Flags.string({
+            description: 'Action config as JSON string',
+        }),
+        'action-type': Flags.string({
+            description: 'Action type (slack-notify, webhook, ci-trigger, etc.)',
+        }),
+        conditions: Flags.string({
+            description: 'Trigger conditions as JSON string (lifecycle hooks only)',
+        }),
+        cron: Flags.string({
+            description: 'Cron expression or rate expression (e.g. "0 3 * * ? *", "rate(1 hour)"). Minimum interval: 5 minutes.',
+            exclusive: ['event', 'conditions'],
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Hyperdrive tenant domain',
+        }),
+        event: Flags.string({
+            description: 'Lifecycle event (e.g., deploy.completed, stage.provisioned)',
+            exclusive: ['cron', 'timezone', 'flexible-window'],
+        }),
+        'flexible-window': Flags.integer({
+            description: 'Flexible time window in minutes for cron hooks (default: 15, max: 1440)',
+            dependsOn: ['cron'],
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON',
+        }),
+        order: Flags.integer({
+            description: 'Execution order (lower runs first)',
+        }),
+        timezone: Flags.string({
+            description: 'IANA timezone for cron expression (default: UTC). E.g. "America/Sao_Paulo"',
+            dependsOn: ['cron'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(HookAdd);
+        const isJson = flags.json ?? false;
+        // Authenticate
+        let apiService;
+        const spinner = isJson ? null : ora('Checking authentication...').start();
+        try {
+            apiService = 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')}`);
+        }
+        // Detect interactive vs non-interactive
+        const hasNonInteractiveFlags = flags.event || flags['action-type'] || flags.cron;
+        if (isJson && !hasNonInteractiveFlags) {
+            this.error('Interactive mode not supported with --json. Provide --event (or --cron) and --action-type flags.');
+        }
+        if (hasNonInteractiveFlags) {
+            await this.runNonInteractive(apiService, flags, isJson);
+        }
+        else {
+            await this.runInteractive(apiService);
+        }
+    }
+    handleApiError(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 (status === 404) {
+                errorMessage = 'Not found';
+            }
+            else if (data?.error) {
+                errorMessage = data.error;
+            }
+            else if (data?.message) {
+                errorMessage = data.message;
+            }
+        }
+        this.error(errorMessage);
+    }
+    printSuccess(hook, trigger, actionType, category, order) {
+        this.log('');
+        this.log(chalk.green('Hook created successfully'));
+        this.log('');
+        this.log(`  Hook ID:        ${chalk.cyan(hook.hookId)}`);
+        if ('type' in trigger && trigger.type === 'cron') {
+            this.log(`  Trigger:        ${chalk.cyan('cron')}`);
+            this.log(`  Expression:     ${chalk.cyan(trigger.expression)}`);
+            this.log(`  Timezone:       ${chalk.cyan(trigger.timezone)}`);
+            if (trigger.flexibleWindowMinutes !== undefined) {
+                this.log(`  Flex Window:    ${chalk.cyan(String(trigger.flexibleWindowMinutes))} min`);
+            }
+        }
+        else if ('event' in trigger) {
+            this.log(`  Event:          ${chalk.cyan(trigger.event)}`);
+            if (trigger.conditions && Object.keys(trigger.conditions).length > 0) {
+                this.log(`  Conditions:     ${chalk.cyan(JSON.stringify(trigger.conditions))}`);
+            }
+        }
+        this.log(`  Action Type:    ${chalk.cyan(actionType)}`);
+        this.log(`  Category:       ${chalk.cyan(category)}`);
+        if (order !== undefined) {
+            this.log(`  Order:          ${chalk.cyan(String(order))}`);
+        }
+        this.log(`  Enabled:        ${hook.enabled ? chalk.green('yes') : chalk.red('no')}`);
+        this.log(`  Created:        ${chalk.dim(hook.createdAt)}`);
+        this.log('');
+    }
+    async runInteractive(apiService) {
+        this.log('');
+        // Step 1: Choose trigger type
+        const triggerType = await promptTriggerType();
+        let trigger;
+        if (triggerType === 'cron') {
+            // Cron trigger flow
+            const expression = await promptCronExpression();
+            const timezone = await promptCronTimezone();
+            const flexibleWindowMinutes = await promptFlexibleWindow();
+            trigger = {
+                expression,
+                timezone,
+                type: 'cron',
+                ...(flexibleWindowMinutes !== undefined && { flexibleWindowMinutes }),
+            };
+        }
+        else {
+            // Lifecycle trigger flow
+            const event = await promptLifecycleEvent();
+            const conditions = await promptLifecycleConditions(event);
+            trigger = {
+                conditions: Object.keys(conditions).length > 0 ? conditions : undefined,
+                event,
+                source: 'hyperdrive',
+            };
+        }
+        // Step 2: Action type (grouped)
+        const { category, type: actionType } = await promptActionTypeV2();
+        // Step 3: Action config
+        const actionConfig = await promptActionConfig(actionType);
+        // Step 4: Order
+        const order = await promptOrder();
+        // Confirmation summary
+        this.log('');
+        this.log(chalk.bold('Summary:'));
+        if ('type' in trigger && trigger.type === 'cron') {
+            this.log(`  Trigger:        ${chalk.cyan('cron')}`);
+            this.log(`  Expression:     ${chalk.cyan(trigger.expression)}`);
+            this.log(`  Timezone:       ${chalk.cyan(trigger.timezone)}`);
+            if (trigger.flexibleWindowMinutes !== undefined) {
+                this.log(`  Flex Window:    ${chalk.cyan(String(trigger.flexibleWindowMinutes))} min`);
+            }
+        }
+        else if ('event' in trigger) {
+            this.log(`  Event:          ${chalk.cyan(trigger.event)}`);
+            if (trigger.conditions && Object.keys(trigger.conditions).length > 0) {
+                this.log(`  Conditions:     ${chalk.cyan(JSON.stringify(trigger.conditions))}`);
+            }
+        }
+        this.log(`  Action Type:    ${chalk.cyan(actionType)}`);
+        this.log(`  Category:       ${chalk.cyan(category)}`);
+        if (order !== undefined) {
+            this.log(`  Order:          ${chalk.cyan(String(order))}`);
+        }
+        this.log('');
+        const { confirmed } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'confirmed',
+                message: 'Create this hook?',
+                default: true,
+            }]);
+        if (!confirmed) {
+            this.log(chalk.yellow('Cancelled'));
+            return;
+        }
+        // Build request
+        const body = {
+            action: { category, config: actionConfig, type: actionType },
+            trigger,
+        };
+        if (order !== undefined)
+            body.order = order;
+        const createSpinner = ora('Creating hook...').start();
+        try {
+            const hook = await apiService.tenantHookCreate(body);
+            createSpinner.succeed('Hook created');
+            this.printSuccess(hook, trigger, actionType, category, order);
+        }
+        catch (error) {
+            createSpinner.fail('Failed to create hook');
+            this.handleApiError(error);
+        }
+    }
+    async runNonInteractive(apiService, flags, isJson) {
+        const isCron = !!flags.cron;
+        let trigger;
+        if (isCron) {
+            // Build cron trigger
+            const expression = flags.cron;
+            const timezone = flags.timezone ?? 'UTC';
+            const flexibleWindowMinutes = flags['flexible-window'];
+            if (timezone === 'UTC' && !flags.timezone && !isJson) {
+                this.warn('No --timezone specified, defaulting to UTC. Consider using --timezone to set your local timezone.');
+            }
+            if (flexibleWindowMinutes !== undefined && (flexibleWindowMinutes < 0 || flexibleWindowMinutes > 1440)) {
+                this.error('--flexible-window must be between 0 and 1440 minutes');
+            }
+            trigger = {
+                expression,
+                timezone,
+                type: 'cron',
+                ...(flexibleWindowMinutes !== undefined && { flexibleWindowMinutes }),
+            };
+        }
+        else {
+            // Lifecycle trigger
+            if (!flags.event) {
+                this.error('--event is required for lifecycle hooks (or use --cron for cron-triggered hooks)');
+            }
+            const event = flags.event;
+            if (!VALID_LIFECYCLE_EVENTS.includes(event)) {
+                this.error(`Invalid lifecycle event: ${event}. Must be one of:\n  ${VALID_LIFECYCLE_EVENTS.join('\n  ')}`);
+            }
+            // Parse optional conditions
+            let conditions;
+            if (flags.conditions) {
+                try {
+                    conditions = JSON.parse(flags.conditions);
+                }
+                catch {
+                    this.error('Invalid JSON in --conditions flag');
+                }
+            }
+            trigger = {
+                conditions,
+                event,
+                source: 'hyperdrive',
+            };
+        }
+        // Validate action type
+        if (!flags['action-type']) {
+            this.error('--action-type is required in non-interactive mode');
+        }
+        const actionType = flags['action-type'];
+        // Parse optional action config
+        let actionConfig = {};
+        if (flags['action-config']) {
+            try {
+                actionConfig = JSON.parse(flags['action-config']);
+            }
+            catch {
+                this.error('Invalid JSON in --action-config flag');
+            }
+        }
+        const category = getActionCategory(actionType);
+        const order = flags.order;
+        // Build request
+        const body = {
+            action: { category, config: actionConfig, type: actionType },
+            trigger,
+        };
+        if (order !== undefined)
+            body.order = order;
+        const createSpinner = isJson ? null : ora('Creating hook...').start();
+        try {
+            const hook = await apiService.tenantHookCreate(body);
+            createSpinner?.succeed('Hook created');
+            if (isJson) {
+                this.log(JSON.stringify(hook, null, 2));
+                return;
+            }
+            this.printSuccess(hook, trigger, actionType, category, order);
+        }
+        catch (error) {
+            createSpinner?.fail('Failed to create hook');
+            this.handleApiError(error);
+        }
+    }
+}

package/dist/commands/hook/list.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class HookList 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>;
+    };
+    run(): Promise<void>;
+    private handleApiError;
+}

package/dist/commands/hook/list.js

@@ -0,0 +1,111 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../utils/table.js';
+export default class HookList extends Command {
+    static description = 'List tenant lifecycle hooks';
+    static examples = [
+        '<%= config.bin %> hook list',
+        '<%= config.bin %> hook list --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Hyperdrive tenant domain',
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(HookList);
+        const isJson = flags.json;
+        // Authenticate
+        let apiService;
+        const spinner = isJson ? null : ora('Checking authentication...').start();
+        try {
+            apiService = 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')}`);
+        }
+        // Fetch hooks
+        const fetchSpinner = isJson ? null : ora('Fetching hooks...').start();
+        try {
+            const hooks = await apiService.tenantHookList();
+            fetchSpinner?.succeed(`Found ${hooks.length} hook${hooks.length === 1 ? '' : 's'}`);
+            if (isJson) {
+                this.log(JSON.stringify(hooks, null, 2));
+                return;
+            }
+            if (hooks.length === 0) {
+                this.log('');
+                this.log(chalk.yellow('No tenant hooks found.'));
+                this.log(chalk.dim(`Run ${chalk.cyan('hd hook add')} to create one.`));
+                this.log('');
+                return;
+            }
+            this.log('');
+            printTable(hooks.map((h) => {
+                const isCron = h.trigger?.type === 'cron';
+                return {
+                    actionType: h.action?.type ?? '',
+                    createdAt: h.createdAt,
+                    cronSchedule: isCron
+                        ? `${h.trigger?.expression ?? ''} (${h.trigger?.timezone ?? 'UTC'})`
+                        : '',
+                    enabled: h.enabled,
+                    hookId: h.hookId,
+                    order: h.order ?? '',
+                    triggerEvent: isCron ? 'cron' : (h.trigger?.event ?? ''),
+                };
+            }), {
+                hookId: { header: 'Hook ID' },
+                triggerEvent: { header: 'Event' },
+                cronSchedule: { header: 'Schedule' },
+                actionType: { header: 'Action Type' },
+                enabled: {
+                    get: (row) => row.enabled ? chalk.green('enabled') : chalk.red('disabled'),
+                    header: 'Enabled',
+                },
+                order: { header: 'Order' },
+                createdAt: {
+                    get: (row) => new Date(row.createdAt).toLocaleDateString(),
+                    header: 'Created',
+                },
+            }, (msg) => this.log(msg));
+            this.log('');
+        }
+        catch (error) {
+            fetchSpinner?.fail('Failed to fetch hooks');
+            this.handleApiError(error);
+        }
+    }
+    handleApiError(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 (status === 404) {
+                errorMessage = 'Not found';
+            }
+            else if (data?.error) {
+                errorMessage = data.error;
+            }
+            else if (data?.message) {
+                errorMessage = data.message;
+            }
+        }
+        this.error(errorMessage);
+    }
+}

package/dist/commands/hook/logs.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class HookLogs 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>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private handleApiError;
+}

package/dist/commands/hook/logs.js

@@ -0,0 +1,124 @@
+import { Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+import { printTable } from '../../utils/table.js';
+export default class HookLogs extends Command {
+    static description = 'View tenant lifecycle hook execution logs';
+    static examples = [
+        '<%= config.bin %> hook logs',
+        '<%= config.bin %> hook logs --status failed --limit 5',
+        '<%= config.bin %> hook logs --json',
+    ];
+    static flags = {
+        domain: Flags.string({
+            char: 'd',
+            description: 'Hyperdrive tenant domain',
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON',
+        }),
+        limit: Flags.integer({
+            default: 20,
+            description: 'Number of log entries to display',
+        }),
+        status: Flags.string({
+            description: 'Filter by execution status',
+            options: ['success', 'failed'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(HookLogs);
+        const isJson = flags.json;
+        // Authenticate
+        let apiService;
+        const spinner = isJson ? null : ora('Checking authentication...').start();
+        try {
+            apiService = 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')}`);
+        }
+        // Fetch hook logs
+        const fetchSpinner = isJson ? null : ora('Fetching hook logs...').start();
+        try {
+            const response = await apiService.tenantHookLogList({
+                limit: flags.limit,
+                status: flags.status,
+            });
+            const items = Array.isArray(response) ? response : (response.items || []);
+            if (items.length === 0) {
+                fetchSpinner?.succeed('No log entries found');
+                if (isJson) {
+                    this.log(JSON.stringify(items, null, 2));
+                    return;
+                }
+                this.log('');
+                this.log(chalk.yellow('No hook execution logs found.'));
+                this.log('');
+                return;
+            }
+            fetchSpinner?.succeed(`Found ${items.length} log entr${items.length === 1 ? 'y' : 'ies'}`);
+            if (isJson) {
+                this.log(JSON.stringify(items, null, 2));
+                return;
+            }
+            this.log('');
+            printTable(items.map(item => ({
+                actionType: item.actionType,
+                durationMs: item.durationMs,
+                hookName: item.hookName,
+                status: item.status,
+                timestamp: item.timestamp,
+                triggerEvent: item.triggerEvent,
+            })), {
+                timestamp: {
+                    get: (row) => new Date(row.timestamp).toLocaleString(),
+                    header: 'Timestamp',
+                },
+                hookName: { header: 'Hook Name' },
+                actionType: { header: 'Action' },
+                triggerEvent: { header: 'Event' },
+                status: {
+                    get: (row) => row.status === 'success' ? chalk.green('success') : chalk.red('failed'),
+                    header: 'Status',
+                },
+                durationMs: {
+                    get: (row) => `${row.durationMs}ms`,
+                    header: 'Duration',
+                },
+            }, (msg) => this.log(msg));
+            this.log('');
+        }
+        catch (error) {
+            fetchSpinner?.fail('Failed to fetch hook logs');
+            this.handleApiError(error);
+        }
+    }
+    handleApiError(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 (status === 404) {
+                errorMessage = 'Not found — verify your tenant domain';
+            }
+            else if (data?.error) {
+                errorMessage = data.error;
+            }
+            else if (data?.message) {
+                errorMessage = data.message;
+            }
+        }
+        this.error(errorMessage);
+    }
+}

package/dist/commands/hook/remove.d.ts

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