@hyperdrive.bot/cli 1.0.13 → 1.0.17

package/dist/commands/{jira → tracker}/connect.js

@@ -4,7 +4,7 @@ import inquirer from 'inquirer';
 import ora from 'ora';
 import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
 export default class JiraConnect extends Command {
-    static description = 'Register your Jira instance with Hyperdrive (run BEFORE installing the Forge app)';
+    static description = 'Connect your tenant to a Jira instance via the Hyperdrive Forge app';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --jira-domain dev-squad.atlassian.net',
@@ -25,8 +25,8 @@ export default class JiraConnect extends Command {
         this.log('');
         this.log(chalk.blue.bold('🔌 Hyperdrive Jira Integration Setup'));
         this.log('');
-        this.log(chalk.dim('This wizard will pre-register your Jira instance with Hyperdrive.'));
-        this.log(chalk.dim('After registration, you\'ll install the Forge app from the Atlassian Marketplace.'));
+        this.log(chalk.dim('This will request a connection between your tenant and a Jira site.'));
+        this.log(chalk.dim('A Jira admin must approve the connection from the Forge app settings.'));
         this.log('');
         // Create API service (automatically checks auth)
         let apiService;
@@ -82,38 +82,47 @@ export default class JiraConnect extends Command {
         // Pre-register domain
         spinner.start('Registering Jira domain with Hyperdrive...');
         try {
-            const response = await apiService['makeSignedRequest']('POST', '/hyperdrive/jira/pre-register', {
-                jiraDomain,
-            });
-            spinner.succeed('Jira domain registered successfully');
-            // Display registration details
+            const response = await apiService.jiraPreRegister({ jiraDomain: jiraDomain });
+            // Handle already connected case
+            if (response.alreadyConnected) {
+                spinner.succeed('Jira instance already connected');
+                this.log('');
+                this.log(chalk.green('✅ Already Connected!'));
+                this.log('');
+                this.log(`  Jira Domain: ${chalk.cyan(response.connection?.jiraDomain)}`);
+                this.log(`  Status: ${chalk.green('active')}`);
+                this.log(`  Connected since: ${chalk.dim(response.connection?.installedAt ? new Date(response.connection.installedAt).toLocaleString() : 'unknown')}`);
+                this.log('');
+                this.log(chalk.dim('Your Jira integration is already active. No action needed.'));
+                this.log(chalk.dim(`Run ${chalk.cyan('hd tracker status')} to see full connection details.`));
+                this.log('');
+                return;
+            }
+            spinner.succeed('Connection request submitted');
             this.log('');
-            this.log(chalk.green('✅ Pre-registration Complete!'));
+            this.log(chalk.green('Connection Request Submitted!'));
             this.log('');
-            this.log(chalk.bold('Registration Details:'));
-            this.log(`  Jira Domain: ${chalk.cyan(response.registration.jiraDomain)}`);
-            this.log(`  Tenant ID: ${chalk.dim(response.registration.tenantId)}`);
-            this.log(`  Registration Token: ${chalk.cyan(response.registration.token)}`);
-            this.log(`  Status: ${chalk.yellow(response.registration.status)}`);
+            this.log(chalk.bold('Request Details:'));
+            this.log(`  Jira Domain: ${chalk.cyan(response.registration?.jiraDomain)}`);
+            this.log(`  Tenant ID: ${chalk.dim(response.registration?.tenantId)}`);
+            this.log(`  Status: ${chalk.yellow('pending approval')}`);
             this.log('');
-            // Show install link prominently if available
+            // Show install link if app not yet installed on the Jira site
             if (response.nextSteps.forgeInstallUrl) {
-                this.log(chalk.bold('Install the Forge App:'));
+                this.log(chalk.bold('Step 1 - Install the Forge App (if not already installed):'));
                 this.log('');
                 this.log(`  ${chalk.cyan.underline(response.nextSteps.forgeInstallUrl)}`);
                 this.log('');
                 this.log(chalk.dim('  Open this link in your browser, select your Jira site, and approve the permissions.'));
                 this.log('');
             }
-            this.log(chalk.bold('Next Steps:'));
-            response.nextSteps.instructions.forEach((instruction, index) => {
-                this.log(`  ${chalk.cyan(`${index + 1}.`)} ${instruction}`);
-            });
+            this.log(chalk.bold(`${response.nextSteps.forgeInstallUrl ? 'Step 2' : 'Next Step'} - Jira Admin Approval:`));
             this.log('');
-            this.log(chalk.dim('💡 Tip: After installing the Forge app, run:'));
-            this.log(chalk.dim(`    ${chalk.cyan('hd jira status')} - to verify the connection`));
+            this.log('  A Jira administrator must approve your connection request.');
+            this.log(`  They can do this from: ${chalk.cyan('Jira Settings > Apps > Hyperdrive > Configure')}`);
+            this.log(`  Your tenant will appear under ${chalk.bold('Pending Connection Requests')}.`);
             this.log('');
-            this.log(chalk.yellow('⚠️  Important: You must install the Forge app for the integration to work!'));
+            this.log(chalk.dim(`Run ${chalk.cyan('hd tracker status')} to check the connection status.`));
             this.log('');
         }
         catch (error) {

package/dist/commands/tracker/hook/add.d.ts

@@ -0,0 +1,25 @@
+import { Command } from '@oclif/core';
+export default class HookAdd extends Command {
+    static args: {
+        project: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'action-config': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'action-type': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'trigger-conditions': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'trigger-event': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        action: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        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>;
+        order: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        status: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private handleApiError;
+    private runLegacyFlow;
+    private runV2Interactive;
+    private runV2NonInteractive;
+}

package/dist/commands/tracker/hook/add.js

@@ -0,0 +1,284 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import ora from 'ora';
+import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+import { ALL_ACTION_TYPES, VALID_TRIGGER_EVENTS, getActionCategory, promptActionConfig, promptActionTypeV2, promptOrder, promptTriggerConditions, promptTriggerEvent, } from '../../../utils/hook-flow.js';
+const LEGACY_ACTION_TYPES = ['adhb-enrich', 'ci-trigger', 'slack-notify', 'webhook'];
+export default class HookAdd extends Command {
+    static args = {
+        project: Args.string({ description: 'Tracker project ID', required: true }),
+    };
+    static description = 'Add an automation hook to a tracker project';
+    static examples = [
+        '<%= config.bin %> tracker hook add my-project',
+        '<%= config.bin %> tracker hook add my-project --trigger-event status_transition --trigger-conditions \'{"statusTo":"In Progress"}\' --action-type git-create-branch --action-config \'{"branchPattern":"{issueKey}/{summary-slug}"}\'',
+        '<%= config.bin %> tracker hook add my-project --trigger-event issue_created --action-type slack-notify --action-config \'{"channel":"#tickets"}\'',
+        '<%= config.bin %> tracker hook add my-project --trigger-event status_transition --action-type git-create-mr --action-config \'{"draft":true}\' --order 2',
+        '<%= config.bin %> tracker hook add my-project --status "In Progress" --action adhb-enrich --config \'{"priority":"high"}\'',
+        '<%= config.bin %> tracker hook add my-project --json',
+    ];
+    static flags = {
+        // V2 flags
+        'action-config': Flags.string({
+            description: '[V2] Action config as JSON string',
+        }),
+        'action-type': Flags.string({
+            description: '[V2] Action type (git-create-branch, git-create-mr, git-delete-branch, slack-notify, adhb-enrich, webhook, ci-trigger)',
+        }),
+        'trigger-conditions': Flags.string({
+            description: '[V2] Trigger conditions as JSON string',
+        }),
+        'trigger-event': Flags.string({
+            description: '[V2] Trigger event (status_transition, issue_created, issue_assigned, field_changed, comment_added, label_changed)',
+        }),
+        // Legacy flags
+        action: Flags.string({
+            description: '[Legacy] Action type (slack-notify, adhb-enrich, webhook, ci-trigger)',
+        }),
+        config: Flags.string({
+            description: '[Legacy] Action config as JSON string',
+        }),
+        domain: Flags.string({
+            char: 'd',
+            description: 'Hyperdrive tenant domain',
+        }),
+        json: Flags.boolean({
+            description: 'Output raw JSON',
+        }),
+        order: Flags.integer({
+            description: 'Execution order (lower runs first)',
+        }),
+        status: Flags.string({
+            description: '[Legacy] Trigger status (Jira status name or "*" for all)',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(HookAdd);
+        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')}`);
+        }
+        // Detect which flag set is in use
+        const hasLegacyFlags = flags.status || flags.action || flags.config;
+        const hasV2Flags = flags['trigger-event'] || flags['action-type'] || flags['trigger-conditions'] || flags['action-config'];
+        // Error if both flag sets are mixed
+        if (hasLegacyFlags && hasV2Flags) {
+            this.error('Cannot mix legacy flags (--status, --action, --config) with V2 flags (--trigger-event, --action-type, --trigger-conditions, --action-config).\n' +
+                'Use one set or the other.');
+        }
+        if (hasLegacyFlags) {
+            await this.runLegacyFlow(apiService, args.project, flags, isJson);
+        }
+        else if (hasV2Flags) {
+            await this.runV2NonInteractive(apiService, args.project, flags, isJson);
+        }
+        else {
+            // No flags — interactive V2 flow
+            if (isJson) {
+                this.error('Interactive mode not supported with --json. Provide --trigger-event and --action-type flags.');
+            }
+            await this.runV2Interactive(apiService, args.project, isJson);
+        }
+    }
+    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 = 'Project not found — verify the project ID';
+            }
+            else if (data?.error) {
+                errorMessage = data.error;
+            }
+            else if (data?.message) {
+                errorMessage = data.message;
+            }
+        }
+        this.error(errorMessage);
+    }
+    async runLegacyFlow(apiService, projectId, flags, isJson) {
+        const hasAllFlags = flags.status && flags.action && flags.config;
+        if (!hasAllFlags) {
+            this.error('Non-interactive legacy mode requires all three flags: --status, --action, and --config\n' +
+                `Missing: ${[!flags.status && '--status', !flags.action && '--action', !flags.config && '--config'].filter(Boolean).join(', ')}`);
+        }
+        const triggerStatus = flags.status;
+        if (!LEGACY_ACTION_TYPES.includes(flags.action)) {
+            this.error(`Invalid action type: ${flags.action}. Must be one of: ${LEGACY_ACTION_TYPES.join(', ')}`);
+        }
+        const actionType = flags.action;
+        let actionConfig;
+        try {
+            actionConfig = JSON.parse(flags.config);
+        }
+        catch {
+            this.error('Invalid JSON in --config flag');
+        }
+        const createSpinner = isJson ? null : ora('Creating hook...').start();
+        try {
+            const body = { actionConfig, actionType, triggerStatus };
+            const hook = await apiService.trackerProjectHookCreate(projectId, body);
+            createSpinner?.succeed('Hook created');
+            if (isJson) {
+                this.log(JSON.stringify(hook, null, 2));
+                return;
+            }
+            this.log('');
+            this.log(chalk.green('Hook created successfully'));
+            this.log('');
+            this.log(`  Hook ID:        ${chalk.cyan(hook.hookId)}`);
+            this.log(`  Trigger Status: ${chalk.cyan(hook.triggerStatus)}`);
+            this.log(`  Action Type:    ${chalk.cyan(hook.actionType)}`);
+            this.log(`  Enabled:        ${hook.enabled ? chalk.green('yes') : chalk.red('no')}`);
+            this.log(`  Created:        ${chalk.dim(hook.createdAt)}`);
+            this.log('');
+        }
+        catch (error) {
+            createSpinner?.fail('Failed to create hook');
+            this.handleApiError(error);
+        }
+    }
+    async runV2Interactive(apiService, projectId, isJson) {
+        this.log('');
+        // Step 1: Trigger event
+        const triggerEvent = await promptTriggerEvent();
+        // Step 2: Trigger conditions
+        const conditions = await promptTriggerConditions(triggerEvent);
+        // Step 3: Action type (grouped)
+        const { category, type: actionType } = await promptActionTypeV2();
+        // Step 4: Action config
+        const actionConfig = await promptActionConfig(actionType);
+        // Step 5: Order
+        const order = await promptOrder();
+        // Create hook
+        const createSpinner = ora('Creating hook...').start();
+        try {
+            const body = {
+                action: { category, config: actionConfig, type: actionType },
+                trigger: {
+                    conditions: Object.keys(conditions).length > 0 ? conditions : undefined,
+                    event: triggerEvent,
+                    source: 'jira',
+                },
+            };
+            if (order !== undefined)
+                body.order = order;
+            const hook = await apiService.trackerProjectHookCreateV2(projectId, body);
+            createSpinner.succeed('Hook created');
+            this.log('');
+            this.log(chalk.green('Hook created successfully'));
+            this.log('');
+            this.log(`  Hook ID:        ${chalk.cyan(hook.hookId)}`);
+            this.log(`  Trigger Event:  ${chalk.cyan(triggerEvent)}`);
+            if (Object.keys(conditions).length > 0) {
+                this.log(`  Conditions:     ${chalk.cyan(JSON.stringify(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('');
+        }
+        catch (error) {
+            createSpinner.fail('Failed to create hook');
+            this.handleApiError(error);
+        }
+    }
+    async runV2NonInteractive(apiService, projectId, flags, isJson) {
+        // Require at minimum --trigger-event and --action-type
+        if (!flags['trigger-event'] || !flags['action-type']) {
+            this.error('V2 non-interactive mode requires at least --trigger-event and --action-type.\n' +
+                `Missing: ${[!flags['trigger-event'] && '--trigger-event', !flags['action-type'] && '--action-type'].filter(Boolean).join(', ')}`);
+        }
+        // Validate trigger event
+        const triggerEvent = flags['trigger-event'];
+        if (!VALID_TRIGGER_EVENTS.includes(triggerEvent)) {
+            this.error(`Invalid trigger event: ${triggerEvent}. Must be one of: ${VALID_TRIGGER_EVENTS.join(', ')}`);
+        }
+        // Validate action type
+        const actionType = flags['action-type'];
+        if (!ALL_ACTION_TYPES.includes(actionType)) {
+            this.error(`Invalid action type: ${actionType}. Must be one of: ${ALL_ACTION_TYPES.join(', ')}`);
+        }
+        // Parse optional conditions
+        let conditions;
+        if (flags['trigger-conditions']) {
+            try {
+                conditions = JSON.parse(flags['trigger-conditions']);
+            }
+            catch {
+                this.error('Invalid JSON in --trigger-conditions flag');
+            }
+        }
+        // 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;
+        const createSpinner = isJson ? null : ora('Creating hook...').start();
+        try {
+            const body = {
+                action: { category, config: actionConfig, type: actionType },
+                trigger: {
+                    conditions,
+                    event: triggerEvent,
+                    source: 'jira',
+                },
+            };
+            if (order !== undefined)
+                body.order = order;
+            const hook = await apiService.trackerProjectHookCreateV2(projectId, body);
+            createSpinner?.succeed('Hook created');
+            if (isJson) {
+                this.log(JSON.stringify(hook, null, 2));
+                return;
+            }
+            this.log('');
+            this.log(chalk.green('Hook created successfully'));
+            this.log('');
+            this.log(`  Hook ID:        ${chalk.cyan(hook.hookId)}`);
+            this.log(`  Trigger Event:  ${chalk.cyan(triggerEvent)}`);
+            if (conditions && Object.keys(conditions).length > 0) {
+                this.log(`  Conditions:     ${chalk.cyan(JSON.stringify(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('');
+        }
+        catch (error) {
+            createSpinner?.fail('Failed to create hook');
+            this.handleApiError(error);
+        }
+    }
+}

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

@@ -2,15 +2,21 @@ import { Args, Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import ora from 'ora';
 import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
+import { normalizeHookToV2 } from '../../../utils/hook-normalize.js';
 import { printTable } from '../../../utils/table.js';
+function formatConditions(conditions) {
+    if (!conditions || Object.keys(conditions).length === 0)
+        return '*';
+    return Object.entries(conditions).map(([k, v]) => `${k}: ${v}`).join(', ');
+}
 export default class HookList 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 = 'List status transition hooks for a Jira-linked project';
+    static description = 'List automation hooks for a tracker project';
     static examples = [
-        '<%= config.bin %> jira hook list my-project',
-        '<%= config.bin %> jira hook list my-project --json',
+        '<%= config.bin %> tracker hook list my-project',
+        '<%= config.bin %> tracker hook list my-project --json',
     ];
     static flags = {
         domain: Flags.string({
@@ -39,8 +45,9 @@ export default class HookList extends Command {
         // Fetch hooks
         const fetchSpinner = isJson ? null : ora('Fetching hooks...').start();
         try {
-            const response = await apiService.hookList(args.project);
-            const hooks = response.hooks;
+            const response = await apiService.trackerProjectHookList(args.project);
+            const rawHooks = Array.isArray(response) ? response : response.hooks;
+            const hooks = rawHooks.map(normalizeHookToV2);
             fetchSpinner?.succeed(`Found ${hooks.length} hook${hooks.length === 1 ? '' : 's'}`);
             if (isJson) {
                 this.log(JSON.stringify(hooks, null, 2));
@@ -49,19 +56,21 @@ export default class HookList extends Command {
             if (hooks.length === 0) {
                 this.log('');
                 this.log(chalk.yellow('No hooks configured for this project'));
-                this.log(chalk.dim(`Run ${chalk.cyan(`hd jira hook add ${args.project}`)} to create one`));
+                this.log(chalk.dim(`Run ${chalk.cyan(`hd tracker hook add ${args.project}`)} to create one`));
                 this.log('');
                 return;
             }
             this.log('');
-            printTable(hooks.map(h => ({
-                actionType: h.actionType,
+            printTable(hooks.map((h) => ({
+                actionType: h.action?.type ?? '',
+                conditions: formatConditions(h.trigger?.conditions),
                 createdAt: h.createdAt,
                 enabled: h.enabled,
                 hookId: h.hookId,
-                triggerStatus: h.triggerStatus,
+                triggerEvent: h.trigger?.event ?? '',
             })), {
-                triggerStatus: { header: 'Trigger Status' },
+                triggerEvent: { header: 'Trigger Event' },
+                conditions: { header: 'Conditions' },
                 actionType: { header: 'Action Type' },
                 enabled: {
                     get: (row) => row.enabled ? chalk.green('enabled') : chalk.red('disabled'),

package/dist/commands/{jira/hook/add.d.ts → tracker/hook/logs.d.ts}

@@ -1,15 +1,14 @@
 import { Command } from '@oclif/core';
-export default class HookAdd extends Command {
+export default class HookLogs extends Command {
     static args: {
         project: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static description: string;
     static examples: string[];
     static flags: {
-        action: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        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>;
+        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>;

package/dist/commands/tracker/hook/logs.js

@@ -0,0 +1,126 @@
+import { Args, 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 args = {
+        project: Args.string({ description: 'Tracker project ID', required: true }),
+    };
+    static description = 'List recent hook execution logs for a tracker project';
+    static examples = [
+        '<%= config.bin %> tracker hook logs my-project',
+        '<%= config.bin %> tracker hook logs my-project --status failed',
+        '<%= config.bin %> tracker hook logs my-project --limit 50',
+        '<%= config.bin %> tracker hook logs my-project --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 { args, 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.trackerProjectHookLogList(args.project, {
+                limit: flags.limit,
+                status: flags.status,
+            });
+            const items = response.items;
+            fetchSpinner?.succeed(`Found ${items.length} log entr${items.length === 1 ? 'y' : 'ies'}`);
+            if (isJson) {
+                this.log(JSON.stringify(items, null, 2));
+                return;
+            }
+            if (items.length === 0) {
+                this.log('');
+                this.log(chalk.yellow('No hook executions found for this project. Hook logs appear after hooks are triggered.'));
+                this.log('');
+                return;
+            }
+            this.log('');
+            printTable(items.map(item => ({
+                actionType: item.actionType,
+                durationMs: item.durationMs,
+                hookId: item.hookId,
+                issueKey: item.issueKey,
+                status: item.status,
+                timestamp: item.timestamp,
+            })), {
+                timestamp: {
+                    get: (row) => new Date(row.timestamp).toLocaleString(),
+                    header: 'Timestamp',
+                },
+                hookId: {
+                    get: (row) => row.hookId.slice(0, 8),
+                    header: 'Hook ID',
+                },
+                actionType: { header: 'Action' },
+                issueKey: { header: 'Issue Key' },
+                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 = 'Project not found — verify the project ID';
+            }
+            else if (data?.error) {
+                errorMessage = data.error;
+            }
+            else if (data?.message) {
+                errorMessage = data.message;
+            }
+        }
+        this.error(errorMessage);
+    }
+}

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

@@ -3,15 +3,16 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { HyperdriveSigV4Service } from '../../../services/hyperdrive-sigv4.js';
 import { promptConfirmDelete, promptSelectHook } from '../../../utils/hook-flow.js';
+import { normalizeHookToV2 } from '../../../utils/hook-normalize.js';
 export default class HookRemove 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 = 'Remove a status transition hook from a Jira-linked project';
+    static description = 'Remove an automation hook from a tracker project';
     static examples = [
-        '<%= config.bin %> jira hook remove my-project',
-        '<%= config.bin %> jira hook remove my-project --hook-id hook-123',
-        '<%= config.bin %> jira hook remove my-project --hook-id hook-123 --json',
+        '<%= config.bin %> tracker hook remove my-project',
+        '<%= config.bin %> tracker hook remove my-project --hook-id hook-123',
+        '<%= config.bin %> tracker hook remove my-project --hook-id hook-123 --json',
     ];
     static flags = {
         domain: Flags.string({
@@ -52,8 +53,8 @@ export default class HookRemove 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('');
@@ -78,7 +79,7 @@ export default class HookRemove extends Command {
         // Delete hook
         const deleteSpinner = isJson ? null : ora('Deleting hook...').start();
         try {
-            const result = await apiService.hookDelete(args.project, hookId);
+            const result = await apiService.trackerProjectHookDelete(args.project, hookId);
             deleteSpinner?.succeed('Hook deleted');
             if (isJson) {
                 this.log(JSON.stringify({ hookId, ...result }, null, 2));