@hyperdrive.bot/cli 1.0.7 → 1.0.9

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

@@ -42,7 +42,7 @@ export declare function promptAccountDetails(existingData?: Partial<AccountAddDa
  * @param accountData - Account details to register
  * @returns AccountResult indicating success or failure
  */
-export declare function registerAccount(accountData: AccountAddData): Promise<AccountResult>;
+export declare function registerAccount(accountData: AccountAddData, tenantDomain?: string): Promise<AccountResult>;
 /**
  * Execute the AWS account add flow
  *
@@ -68,7 +68,7 @@ export declare function promptOpenCloudFormation(quickCreateUrl: string): Promis
 /**
  * Wait for role verification with polling
  */
-export declare function waitForRoleVerification(accountId: string, onProgress?: (message: string) => void): Promise<{
+export declare function waitForRoleVerification(accountId: string, onProgress?: (message: string) => void, tenantDomain?: string): Promise<{
     message?: string;
     verified: boolean;
 }>;

package/dist/utils/account-flow.js

@@ -97,10 +97,10 @@ export async function promptAccountDetails(existingData) {
  * @param accountData - Account details to register
  * @returns AccountResult indicating success or failure
  */
-export async function registerAccount(accountData) {
+export async function registerAccount(accountData, tenantDomain) {
     try {
         // Initialize API service
-        const service = new HyperdriveSigV4Service();
+        const service = new HyperdriveSigV4Service(tenantDomain);
         // Make API call to add account
         const result = await service.accountAdd({
             accountId: accountData.accountId,
@@ -190,8 +190,8 @@ const VERIFY_TIMEOUT = 300000; // 5 minutes
 /**
  * Wait for role verification with polling
  */
-export async function waitForRoleVerification(accountId, onProgress) {
-    const service = new HyperdriveSigV4Service();
+export async function waitForRoleVerification(accountId, onProgress, tenantDomain) {
+    const service = new HyperdriveSigV4Service(tenantDomain);
     const startTime = Date.now();
     let attemptCount = 0;
     while (Date.now() - startTime < VERIFY_TIMEOUT) {

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

@@ -3,6 +3,7 @@
  */
 export interface GitConnectOptions {
     callbackPort?: number;
+    domain?: string;
     logger?: (message: string) => void;
     provider?: 'github' | 'gitlab';
     timeout?: number;

package/dist/utils/git-flow.js

@@ -159,7 +159,7 @@ export function waitForCallback(expectedState, port = 8765, timeout = 5 * 60 * 1
  * @returns GitConnectResult indicating success or failure
  */
 export async function executeGitConnect(options = {}) {
-    const { callbackPort = 8765, logger = () => { }, // No-op by default
+    const { callbackPort = 8765, domain, logger = () => { }, // No-op by default
     provider: initialProvider, timeout = 5 * 60 * 1000, } = options;
     try {
         // Step 1: Determine provider (prompt if not specified)
@@ -175,7 +175,7 @@ export async function executeGitConnect(options = {}) {
             provider = selected;
         }
         // Step 2: Initialize API service
-        const service = new HyperdriveSigV4Service();
+        const service = new HyperdriveSigV4Service(domain);
         // Step 3: Initiate OAuth flow via API
         const authResponse = await service.gitAuthInitiate(provider);
         logger(`Opening browser for ${provider === 'github' ? 'GitHub' : 'GitLab'} authorization...`);

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

@@ -0,0 +1,21 @@
+import type { HookActionType, HookResponse } from '../services/hyperdrive-sigv4.js';
+/**
+ * Prompt user to select a trigger status from available Jira statuses
+ */
+export declare function promptTriggerStatus(statuses: string[]): Promise<string>;
+/**
+ * Prompt user to select an action type
+ */
+export declare function promptActionType(): Promise<HookActionType>;
+/**
+ * Prompt for action-specific configuration based on action type
+ */
+export declare function promptActionConfig(actionType: HookActionType): Promise<Record<string, unknown>>;
+/**
+ * Prompt user to select a hook from a list
+ */
+export declare function promptSelectHook(hooks: HookResponse[]): Promise<HookResponse>;
+/**
+ * Prompt user to confirm hook deletion
+ */
+export declare function promptConfirmDelete(hook: HookResponse): Promise<boolean>;

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);