hub-launch 1.0.3

package/dist/commands/interactive.js

@@ -0,0 +1,1071 @@
+import inquirer from 'inquirer';
+import { logger } from '../utils/logger.js';
+import { TrackingService } from '../services/tracking/TrackingService.js';
+import { TrackingAdapterFactory } from '../services/tracking/TrackingAdapterFactory.js';
+import { PRService } from '../services/github/PRService.js';
+import { StatusPollingAdapterFactory } from '../services/polling/StatusPollingAdapterFactory.js';
+import { MIN_POLL_INTERVAL_SECONDS } from '../types/common.schema.js';
+import { HulaApiClient } from '../services/api/HulaApiClient.js';
+import { executeLogs } from './logs.js';
+import { select, confirm, selectPriority } from '../utils/prompts.js';
+import { DEFAULT_PRIORITY_LEVELS, STATUS } from '../types/common.schema.js';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+/**
+ * Max listeners for stdin to prevent MaxListenersExceededWarning during background polling.
+ * Default Node.js limit is 10, we set to 20 as a safety measure.
+ */
+const MAX_STDIN_LISTENERS = 20;
+/**
+ * Interactive command - Full interactive TUI mode
+ * Not used - kept for backwards compatibility
+ */
+export function interactiveCommand(_program, _config) {
+    // This is not registered as a command - it's called directly from index.ts
+    // when no args are provided
+}
+/**
+ * Main entry point for interactive mode
+ */
+export async function executeInteractive(config) {
+    // Increase stdin max listeners to prevent warnings during background polling
+    // Note: This is a fallback - the root cause is fixed by properly cleaning up listeners
+    if (process.stdin.setMaxListeners) {
+        process.stdin.setMaxListeners(MAX_STDIN_LISTENERS);
+    }
+    const trackingService = new TrackingService(TrackingAdapterFactory.create(config));
+    const state = {
+        page: 0,
+        pageSize: parseInt(process.env.PAGE_SIZE ?? '10', 10),
+        filter: '',
+        lastRefreshTime: new Date(),
+        lastPollingCheckTime: undefined,
+        pendingRefresh: false,
+        shouldAutoRefresh: false,
+    };
+    let running = true;
+    // Start background polling for status changes via configurable adapter
+    let pollingInterval = null;
+    try {
+        const pollingAdapter = StatusPollingAdapterFactory.create(config, trackingService);
+        const intervalSeconds = Math.max(config.pollIntervalSeconds, MIN_POLL_INTERVAL_SECONDS);
+        logger.info(`🔄 Auto-refresh: ${pollingAdapter.name} (every ${intervalSeconds}s)`);
+        logger.blank();
+        pollingInterval = startStatusPolling(pollingAdapter, trackingService, config, state);
+    }
+    catch (error) {
+        logger.warning(`⚠️  Auto-refresh disabled: ${error instanceof Error ? error.message : String(error)}`);
+        logger.blank();
+    }
+    while (running) {
+        // Get all issues
+        let allIssues = await trackingService.getAll();
+        // Update refresh tracking
+        state.lastRefreshTime = new Date();
+        state.pendingRefresh = false;
+        state.shouldAutoRefresh = false;
+        // Filter out closed issues (by actual GitHub state, not tracking status)
+        allIssues = allIssues.filter((issue) => issue.githubState !== 'closed');
+        // Apply filter if set
+        if (state.filter) {
+            const filterLower = state.filter.toLowerCase();
+            allIssues = allIssues.filter((issue) => issue.name.toLowerCase().includes(filterLower) ||
+                (issue.number && issue.number.toString().includes(filterLower)));
+        }
+        if (allIssues.length === 0) {
+            // No issues tracked - show empty state menu
+            running = await showEmptyStateMenu(config, trackingService);
+            continue;
+        }
+        // Calculate pagination
+        const totalPages = Math.ceil(allIssues.length / state.pageSize);
+        const startIdx = state.page * state.pageSize;
+        const endIdx = Math.min(startIdx + state.pageSize, allIssues.length);
+        const pageIssues = allIssues.slice(startIdx, endIdx);
+        // Display issues
+        displayIssueList(pageIssues, state, totalPages, allIssues.length, config);
+        // Show prompt with available actions (with auto-refresh capability)
+        const action = await promptForActionWithAutoRefresh(state, totalPages);
+        // Handle action
+        const continueLoop = await handleAction(action, pageIssues, state, config, trackingService, totalPages);
+        if (!continueLoop) {
+            running = false;
+        }
+    }
+    // Stop polling when exiting
+    if (pollingInterval) {
+        clearInterval(pollingInterval);
+    }
+    logger.success('Goodbye!');
+}
+/**
+ * Display paginated issue list
+ */
+function displayIssueList(issues, state, totalPages, totalIssues, config) {
+    console.clear();
+    logger.section('HubLaunch - Tracked Issues');
+    // Show polling status
+    const intervalSeconds = Math.max(config.pollIntervalSeconds, MIN_POLL_INTERVAL_SECONDS);
+    const intervalText = intervalSeconds < 60
+        ? `${intervalSeconds}s`
+        : `${Math.floor(intervalSeconds / 60)}m`;
+    logger.info(`🔄 Auto-refresh: ${config.pollingProvider ?? 'hula-server'} (every ${intervalText})`);
+    logger.blank();
+    if (state.filter) {
+        logger.info(`🔍 Filter: "${state.filter}"`);
+        logger.blank();
+    }
+    // Display each issue with number, status, priority, and deployment status.
+    issues.forEach((issue, idx) => {
+        const displayNum = idx + 1;
+        const statusEmoji = getStatusEmoji(issue.trackingStatus);
+        const priorityEmoji = getPriorityEmoji(issue.priority);
+        const deploymentEmoji = getDeploymentEmoji(issue.deploymentStatus);
+        logger.info(`  ${displayNum}) ${issue.trackingName} (#${issue.number}) [${priorityEmoji} ${issue.priority}] [${statusEmoji} ${issue.trackingStatus}] [${deploymentEmoji} deployment]`);
+    });
+    logger.blank();
+    logger.info(`Page ${state.page + 1} of ${totalPages} (${totalIssues} total issues)`);
+    // Show last refresh timestamp
+    const refreshTimestamp = state.lastRefreshTime.toLocaleTimeString();
+    logger.info(`🔄 Last refreshed: ${refreshTimestamp}`);
+    // Show pending refresh indicator
+    if (state.pendingRefresh) {
+        logger.warning(`⚠️  Updates detected - press Enter to refresh`);
+    }
+    logger.blank();
+}
+/**
+ * Prompt user for action with auto-refresh support
+ * Checks periodically if auto-refresh is triggered and returns 'r' automatically
+ * Uses native readline for better control over event listener cleanup
+ */
+async function promptForActionWithAutoRefresh(state, totalPages) {
+    const hints = ['Enter number to select', '/term to search'];
+    if (totalPages > 1) {
+        if (state.page > 0)
+            hints.push('p for prev');
+        if (state.page < totalPages - 1)
+            hints.push('n for next');
+    }
+    hints.push('r to refresh', 'a for admin', '? for help', 'q to quit');
+    logger.info(`💡 ${hints.join(' · ')}`);
+    logger.blank();
+    // Import readline for better control over event listeners
+    const readline = await import('readline');
+    // Track interval ID and readline interface for cleanup
+    let checkIntervalId = null;
+    let rl = null;
+    return new Promise((resolve) => {
+        // Create readline interface
+        rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        // Display prompt
+        rl.setPrompt('Choice: ');
+        rl.prompt();
+        // Flag to track if already resolved
+        let resolved = false;
+        // Handle user input
+        const lineHandler = (line) => {
+            if (!resolved) {
+                resolved = true;
+                cleanup();
+                resolve(line.trim());
+            }
+        };
+        // Handle close events
+        const closeHandler = () => {
+            if (!resolved) {
+                resolved = true;
+                cleanup();
+                resolve(''); // Return empty string if closed unexpectedly
+            }
+        };
+        // Attach event listeners
+        rl.on('line', lineHandler);
+        rl.once('close', closeHandler);
+        // Start auto-refresh check
+        checkIntervalId = setInterval(() => {
+            if (state.shouldAutoRefresh && !resolved) {
+                resolved = true;
+                cleanup();
+                resolve('r'); // Simulate user pressing 'r'
+            }
+        }, 100); // Check every 100ms
+        // Cleanup function
+        function cleanup() {
+            // Clear the interval
+            if (checkIntervalId) {
+                clearInterval(checkIntervalId);
+                checkIntervalId = null;
+            }
+            // Remove event listeners and close readline
+            if (rl) {
+                rl.removeListener('line', lineHandler);
+                rl.removeListener('close', closeHandler);
+                // Attempt to close interface - will fail silently if already closed
+                // This prevents ERR_USE_AFTER_CLOSE when user presses Ctrl+C
+                try {
+                    rl.close();
+                }
+                catch (closeError) {
+                    // Interface was already closed (e.g., by Ctrl+C), this is expected
+                    // Silently ignore this error
+                }
+                rl = null;
+            }
+        }
+    });
+}
+/**
+ * Handle user action
+ */
+async function handleAction(action, pageIssues, state, config, trackingService, totalPages) {
+    // Quit
+    if (action.toLowerCase() === 'q') {
+        return false;
+    }
+    // Help
+    if (action === '?') {
+        showHelp();
+        await waitForEnter();
+        return true;
+    }
+    // Admin menu
+    if (action.toLowerCase() === 'a') {
+        await showAdminMenu(config, trackingService);
+        return true;
+    }
+    // Next page
+    if (action.toLowerCase() === 'n' && state.page < totalPages - 1) {
+        state.page++;
+        return true;
+    }
+    // Previous page
+    if (action.toLowerCase() === 'p' && state.page > 0) {
+        state.page--;
+        return true;
+    }
+    // Manual refresh
+    if (action.toLowerCase() === 'r' || action.toLowerCase() === 'refresh') {
+        // Just return true to continue loop - data will be refreshed at loop start
+        // Clear pending flag since user explicitly requested refresh
+        state.pendingRefresh = false;
+        return true;
+    }
+    // Clear filter
+    if (action === '' && state.filter) {
+        state.filter = '';
+        state.page = 0;
+        return true;
+    }
+    // Search/filter
+    if (action.startsWith('/')) {
+        state.filter = action.slice(1);
+        state.page = 0;
+        return true;
+    }
+    // Numeric selection
+    const num = parseInt(action.replace(/\)$/, ''), 10);
+    if (!isNaN(num) && num >= 1 && num <= pageIssues.length) {
+        const selectedIssue = pageIssues[num - 1];
+        if (selectedIssue) {
+            await showIssueActionsMenu(selectedIssue, config, trackingService, state);
+        }
+        // Clear filter after handling an issue (bash behavior)
+        state.filter = '';
+        return true;
+    }
+    // Invalid input
+    logger.error('Invalid input. Press ? for help.');
+    await waitForEnter();
+    return true;
+}
+/**
+ * Show empty state menu when no issues are tracked
+ */
+async function showEmptyStateMenu(config, _trackingService) {
+    console.clear();
+    logger.section('HubLaunch - No Tracked Issues');
+    logger.blank();
+    logger.warning('No tracked issues found.');
+    logger.blank();
+    const action = await select('What would you like to do?', [
+        'Track existing issues',
+        'Create new issue',
+        'Initialize/configure',
+        'Quit',
+    ]);
+    switch (action) {
+        case 'Track existing issues':
+            await runCommand('track', config);
+            break;
+        case 'Create new issue':
+            await runCommand('create', config);
+            break;
+        case 'Initialize/configure':
+            await runCommand('init', config);
+            break;
+        case 'Quit':
+            return false;
+    }
+    return true;
+}
+/**
+ * Show issue actions menu for a selected issue
+ */
+async function showIssueActionsMenu(issue, config, trackingService, state) {
+    let inMenu = true;
+    while (inMenu) {
+        // Refresh issue data to get latest status
+        const allIssues = await trackingService.getAll();
+        const currentIssue = allIssues.find((i) => issue.number != null ? i.number === issue.number : i.name === issue.name) ?? issue;
+        console.clear();
+        logger.section(`Issue: ${currentIssue.name} (#${currentIssue.number})`);
+        logger.blank();
+        logger.info('📋 View:');
+        logger.info('  i) Open issue in browser');
+        logger.info('  p) Open plan file');
+        logger.info('  v) Preview deployment');
+        logger.info('  d) View code changes (diff)');
+        logger.info('  r) View PR in browser');
+        logger.info('  l) Latest Copilot comment');
+        logger.info('  w) Watch tests');
+        logger.info('  g) Get logs by ID');
+        // Per-task job-status menu items (`j`/`y`) were removed when the
+        // local schema dropped the `job*` fields with the Plan/Project/Task
+        // rename.
+        logger.blank();
+        logger.info('⚙️  Manage:');
+        logger.info('  c) Checkout PR branch');
+        logger.info('  m) Merge PR');
+        logger.info('  s) Set priority');
+        // Show assign to Copilot option only for unassigned issues
+        if (currentIssue.trackingStatus === STATUS.UNASSIGNED) {
+            logger.info('  t) Assign to Copilot');
+        }
+        logger.info('  u) Untrack issue');
+        logger.info('  o) Respond to Copilot');
+        logger.info('  x) Close issue & untrack');
+        logger.blank();
+        logger.info('🔙 Other:');
+        logger.info('  b) Back to issue list');
+        logger.info('  a) Admin actions');
+        logger.info('  ?) Help');
+        logger.info('  q) Quit');
+        logger.blank();
+        // Display current status
+        const statusEmoji = getStatusEmoji(currentIssue.trackingStatus);
+        const deploymentEmoji = getDeploymentEmoji(currentIssue.deploymentStatus);
+        logger.info(`📊 Current Status: ${statusEmoji} ${currentIssue.trackingStatus}`);
+        logger.info(`🚀 Deployment: ${deploymentEmoji}`);
+        // Per-task job status display was removed with the rename.
+        // Show last polling check time if available, otherwise current time
+        const lastCheckedTime = state.lastPollingCheckTime
+            ? state.lastPollingCheckTime.toLocaleTimeString()
+            : new Date().toLocaleTimeString();
+        logger.info(`🕐 Last checked: ${lastCheckedTime}`);
+        logger.blank();
+        // Use native readline for proper cleanup of event listeners
+        const readline = await import('readline');
+        // Track interval ID and readline interface for cleanup
+        let checkIntervalId = null;
+        let rl = null;
+        const action = await new Promise((resolve) => {
+            // Create readline interface
+            rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            // Display prompt
+            rl.setPrompt('Enter action: ');
+            rl.prompt();
+            // Flag to track if already resolved
+            let resolved = false;
+            // Handle user input
+            const lineHandler = (line) => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve(line.trim().toLowerCase());
+                }
+            };
+            // Handle close events
+            const closeHandler = () => {
+                if (!resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve(''); // Return empty string if closed unexpectedly
+                }
+            };
+            // Attach event listeners
+            rl.on('line', lineHandler);
+            rl.once('close', closeHandler);
+            // Start auto-refresh check
+            checkIntervalId = setInterval(() => {
+                if (state.shouldAutoRefresh && !resolved) {
+                    resolved = true;
+                    cleanup();
+                    resolve('refresh'); // Auto-refresh triggered by background poller
+                }
+            }, 100); // Check flag every 100ms instead of polling API
+            // Cleanup function
+            function cleanup() {
+                // Clear the interval
+                if (checkIntervalId) {
+                    clearInterval(checkIntervalId);
+                    checkIntervalId = null;
+                }
+                // Remove event listeners and close readline
+                if (rl) {
+                    rl.removeListener('line', lineHandler);
+                    rl.removeListener('close', closeHandler);
+                    // Attempt to close interface - will fail silently if already closed
+                    // This prevents ERR_USE_AFTER_CLOSE when user presses Ctrl+C
+                    try {
+                        rl.close();
+                    }
+                    catch (closeError) {
+                        // Interface was already closed (e.g., by Ctrl+C), this is expected
+                        // Silently ignore this error
+                    }
+                    rl = null;
+                }
+            }
+        });
+        // If auto-refresh triggered, just loop again to redraw
+        if (action === 'refresh') {
+            continue;
+        }
+        const continueMenu = await handleIssueAction(action, currentIssue, config, trackingService);
+        if (!continueMenu) {
+            inMenu = false;
+        }
+    }
+}
+/**
+ * Handle action within issue menu
+ */
+async function handleIssueAction(action, issue, config, trackingService) {
+    switch (action) {
+        case 'i':
+            // Open issue in browser
+            logger.info(`Opening issue #${issue.number} in browser...`);
+            try {
+                let owner = issue.projectOwner;
+                let repo = issue.projectName;
+                // Fallback: try to parse from name if repoOwner/repoName not available
+                if (!owner || !repo) {
+                    // Try parsing from name (owner/repo#number format)
+                    const parts = issue.name.split('/');
+                    if (parts.length >= 2) {
+                        owner = parts[0];
+                        const repoAndNumber = parts[1]?.split('#');
+                        repo = repoAndNumber?.[0];
+                    }
+                }
+                if (owner && repo) {
+                    const url = `https://github.com/${owner}/${repo}/issues/${issue.number}`;
+                    const { openUrlSync } = await import('../utils/open-url.js');
+                    openUrlSync(url);
+                    logger.success('✓ Browser opened');
+                }
+                else {
+                    logger.error('Could not determine repository. Please open manually.');
+                    logger.error(`Issue data: name=${issue.name}, number=${issue.number}`);
+                    logger.error(`  projectOwner=${issue.projectOwner}, projectName=${issue.projectName}`);
+                    logger.error(`  Full issue object: ${JSON.stringify(issue, null, 2)}`);
+                }
+            }
+            catch (error) {
+                logger.error('Failed to open issue in browser');
+                logger.error(error instanceof Error ? error.message : String(error));
+            }
+            await waitForEnter();
+            return true;
+        case 'p':
+            // Open plan file
+            if (issue.planPath) {
+                logger.info(`Opening plan file: ${issue.planPath}`);
+                try {
+                    const { EditorService } = await import('../services/editor/EditorService.js');
+                    const editorService = new EditorService(config.editorCommand);
+                    await editorService.openFile(issue.planPath);
+                    logger.success('✓ Plan file opened');
+                }
+                catch (error) {
+                    logger.error(`Failed to open plan file: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            else {
+                logger.warning(`No plan file found for issue #${issue.number}`);
+            }
+            await waitForEnter();
+            return true;
+        case 'v':
+            // Preview deployment
+            if (!issue.number) {
+                logger.warning('Preview not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            await runCommand('preview', config, [issue.number.toString()]);
+            return true;
+        case 'd':
+            // View diff
+            if (!issue.number) {
+                logger.warning('Diff not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            await runCommand('diff', config, [issue.number.toString()]);
+            await waitForEnter();
+            return true;
+        case 'r':
+            // View PR in browser
+            if (!issue.number) {
+                logger.warning('PR not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            logger.info(`Opening PR for issue #${issue.number} in browser...`);
+            try {
+                // Check if issue has a PR URL already
+                if (issue.prUrl) {
+                    const { openUrlSync } = await import('../utils/open-url.js');
+                    openUrlSync(issue.prUrl);
+                    logger.success('✓ Browser opened');
+                }
+                else {
+                    // Find PR linked to issue using GitHub CLI
+                    const prOutput = execSync(`gh pr list --search "closes:#${issue.number} OR fixes:#${issue.number}" --json number,url --limit 1`, { encoding: 'utf-8' });
+                    const prs = JSON.parse(prOutput);
+                    if (prs.length > 0 && prs[0]) {
+                        const { openUrlSync } = await import('../utils/open-url.js');
+                        openUrlSync(prs[0].url);
+                        logger.success('✓ Browser opened');
+                    }
+                    else {
+                        logger.warning(`No PR found for issue #${issue.number}`);
+                    }
+                }
+            }
+            catch (error) {
+                logger.error('Failed to open PR in browser');
+                logger.error(error instanceof Error ? error.message : String(error));
+            }
+            await waitForEnter();
+            return true;
+        case 'w':
+            // Watch tests
+            if (!issue.number) {
+                logger.warning('Watch not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            await runCommand('watch', config, [issue.number.toString()]);
+            await waitForEnter();
+            return true;
+        case 'g':
+            // Get logs by ID
+            await promptAndViewLogs(config);
+            await waitForEnter();
+            return true;
+        case 'j':
+            // Job status / job logs UI was removed with the Plan/Project/Task
+            // rename (the local schema no longer carries job* fields).
+            logger.warning('Per-task job status is no longer available in interactive mode.');
+            await waitForEnter();
+            return true;
+        case 'y':
+            logger.warning('Per-task job logs are no longer available in interactive mode.');
+            await waitForEnter();
+            return true;
+        case 'c':
+            // Checkout PR branch
+            if (!issue.number) {
+                logger.warning('Checkout not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            await runCommand('checkout', config, [issue.number.toString()]);
+            return true;
+        case 'm':
+            // Merge PR
+            if (!issue.number) {
+                logger.warning('Merge not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            await runCommand('merge', config, [issue.number.toString()]);
+            return false; // Return to main menu after merge
+        case 's':
+            // Set priority
+            if (!issue.number) {
+                logger.warning('Priority update not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            try {
+                // Validate config
+                if (!config.hulaProjectUrl || !config.hulaApiKey) {
+                    throw new Error('Hula project URL and API key are required. Run "hula init" to configure.');
+                }
+                // Show current priority
+                if (issue.priority) {
+                    const currentLevel = DEFAULT_PRIORITY_LEVELS.find((level) => level.name === issue.priority);
+                    if (currentLevel) {
+                        logger.info(`Current priority: ${currentLevel.emoji} ${issue.priority}`);
+                    }
+                }
+                else {
+                    logger.info('Current priority: None');
+                }
+                logger.blank();
+                // Select new priority
+                const newPriority = await selectPriority('Select new priority:', DEFAULT_PRIORITY_LEVELS);
+                const priorityLevel = DEFAULT_PRIORITY_LEVELS.find((level) => level.name === newPriority);
+                if (!priorityLevel) {
+                    throw new Error(`Invalid priority: ${newPriority}`);
+                }
+                // Update priority via hula-project API
+                logger.info(`Setting priority to ${priorityLevel.emoji} ${newPriority}...`);
+                const apiClient = new HulaApiClient({
+                    baseUrl: config.hulaProjectUrl,
+                    apiKey: config.hulaApiKey,
+                });
+                // Get the server-side plan ID (paginate to avoid missing plans beyond first page)
+                let allServerIssues = [];
+                let priorityPage = 1;
+                let priorityTotalPages = 1;
+                do {
+                    const resp = await apiClient.listPlans({ page: priorityPage, limit: 100 });
+                    allServerIssues = allServerIssues.concat(resp.plans);
+                    priorityTotalPages = resp.totalPages;
+                    priorityPage++;
+                } while (priorityPage <= priorityTotalPages);
+                const serverIssue = allServerIssues.find((i) => i.issueNumber === issue.number && i.project.owner === issue.projectOwner && i.project.name === issue.projectName);
+                if (!serverIssue) {
+                    throw new Error(`Plan #${issue.number} not found on server`);
+                }
+                await apiClient.updatePlanPriority(serverIssue.id, newPriority);
+                logger.success(`✓ Priority updated successfully`);
+            }
+            catch (error) {
+                logger.error(`Failed to set priority: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            await waitForEnter();
+            return true;
+        case 't':
+            // Assign to Copilot
+            if (!issue.number) {
+                logger.warning('Assign to Copilot not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            logger.info(`Assigning GitHub Copilot to issue #${issue.number}...`);
+            try {
+                const { CopilotService } = await import('../services/github/CopilotService.js');
+                const copilotService = new CopilotService(config);
+                const assigned = await copilotService.assignToIssue(issue.number);
+                if (assigned) {
+                    logger.success(`✓ GitHub Copilot assigned to issue #${issue.number}`);
+                }
+                else {
+                    logger.warning('Could not assign GitHub Copilot automatically');
+                    logger.info('You may need to assign Copilot manually in the GitHub UI');
+                    // Check for debug screenshot
+                    const { tmpdir } = await import('os');
+                    const { join } = await import('path');
+                    const { existsSync } = await import('fs');
+                    const debugPath = join(tmpdir(), 'github-copilot-not-found.png');
+                    if (existsSync(debugPath)) {
+                        logger.info(`📸 Debug screenshot saved to: ${debugPath}`);
+                    }
+                }
+            }
+            catch (error) {
+                logger.error(`Failed to assign Copilot: ${error instanceof Error ? error.message : String(error)}`);
+                // Check for debug screenshot on error
+                try {
+                    const { tmpdir } = await import('os');
+                    const { join } = await import('path');
+                    const { existsSync } = await import('fs');
+                    const debugPath = join(tmpdir(), 'github-copilot-not-found.png');
+                    if (existsSync(debugPath)) {
+                        logger.info(`📸 Debug screenshot saved to: ${debugPath}`);
+                    }
+                }
+                catch {
+                    // Ignore errors checking for screenshot
+                }
+            }
+            await waitForEnter();
+            return true;
+        case 'u':
+            // Untrack issue
+            if (!issue.number) {
+                // For standalone jobs, we can still untrack by name
+                const confirmUntrackStandalone = await confirm(`Remove standalone job "${issue.trackingName || issue.name}" from tracking?`, false);
+                if (confirmUntrackStandalone) {
+                    await trackingService.removeByName(issue.name);
+                    logger.success(`Standalone job removed from tracking`);
+                    await waitForEnter();
+                    return false;
+                }
+                return true;
+            }
+            const confirmUntrack = await confirm(`Remove issue #${issue.number} from tracking? (The issue and PR will remain open in GitHub)`, false);
+            if (confirmUntrack) {
+                await trackingService.removeByName(issue.name);
+                logger.success(`Issue #${issue.number} removed from tracking`);
+                await waitForEnter();
+                return false; // Return to main menu
+            }
+            return true;
+        case 'o':
+            // Respond to Copilot
+            if (!issue.number) {
+                logger.warning('Respond not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            await runCommand('respond', config, [issue.number.toString()]);
+            return true;
+        case 'x':
+            // Close issue & untrack
+            if (!issue.number) {
+                logger.warning('Close & untrack not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            const confirmClose = await confirm(`Close issue #${issue.number} and remove from tracking?`, false);
+            if (confirmClose) {
+                // runCommand('close') spawns a subprocess that closes the issue on GitHub
+                // AND removes it from tracking (via trackingService.remove()). Do NOT call
+                // removeByName() again — the issue is already untracked and a second remove
+                // would throw "Issue not found on server", crashing interactive mode.
+                const ok = await runCommand('close', config, [issue.number.toString()]);
+                if (ok) {
+                    logger.success(`Issue #${issue.number} closed and untracked`);
+                }
+                else {
+                    logger.warning(`Close command for issue #${issue.number} did not complete cleanly. See output above.`);
+                }
+                await waitForEnter();
+                return false; // Return to main menu
+            }
+            return true;
+        case 'l':
+            // Latest Copilot comment
+            if (!issue.number) {
+                logger.warning('Copilot comments not available for standalone jobs');
+                await waitForEnter();
+                return true;
+            }
+            logger.info(`Fetching latest comment for issue #${issue.number}...`);
+            try {
+                const prService = new PRService();
+                const comment = await prService.getLatestCopilotCommentForIssue(issue.number);
+                if (comment) {
+                    const content = `Author: ${comment.author}\nDate: ${comment.date}\n\n${comment.body}`;
+                    // Write to temp file with unique name
+                    const timestamp = Date.now();
+                    const tempFilePath = path.join(os.tmpdir(), `${issue.number}-${timestamp}copilotComment.md`);
+                    fs.writeFileSync(tempFilePath, content);
+                    // Make file readonly
+                    fs.chmodSync(tempFilePath, 0o444);
+                    // Open in IDE
+                    const { EditorService } = await import('../services/editor/EditorService.js');
+                    const editorService = new EditorService(config.editorCommand);
+                    await editorService.openFile(tempFilePath);
+                    logger.success('✓ Latest comment opened in editor');
+                }
+                else {
+                    logger.warning(`No comments found or no PR linked to issue #${issue.number}`);
+                }
+            }
+            catch (error) {
+                logger.error(`Failed to get latest comment: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            await waitForEnter();
+            return true;
+        case 'b':
+            // Back to list
+            return false;
+        case 'a':
+            // Admin actions
+            await showAdminMenu(config, trackingService);
+            return true;
+        case '?':
+            // Help
+            showHelp();
+            await waitForEnter();
+            return true;
+        case 'q':
+            // Quit entire program
+            process.exit(0);
+        default:
+            logger.error('Invalid action. Press ? for help.');
+            await waitForEnter();
+            return true;
+    }
+}
+/**
+ * Show admin actions menu
+ */
+async function showAdminMenu(config, _trackingService) {
+    console.clear();
+    logger.section('Admin Actions');
+    logger.blank();
+    const action = await select('Select action:', [
+        'Initialize/reconfigure',
+        'Create new issue',
+        'Track existing issues',
+        'Clean closed issues',
+        'Clean browsers',
+        'Back',
+    ]);
+    switch (action) {
+        case 'Initialize/reconfigure':
+            await runCommand('init', config);
+            break;
+        case 'Create new issue':
+            await runCommand('create', config);
+            break;
+        case 'Track existing issues':
+            await runCommand('track', config);
+            break;
+        case 'Clean closed issues':
+            await runCommand('clean', config);
+            break;
+        case 'Clean browsers':
+            await runCommand('clean', config, ['--browsers']);
+            // Brief pause then return to menu (no key press needed)
+            // await new Promise((resolve) => setTimeout(resolve, 500));
+            return;
+        case 'Back':
+            return;
+    }
+    await waitForEnter();
+}
+/**
+ * Run a hublaunch command
+ */
+async function runCommand(command, _config, args = []) {
+    try {
+        // On Windows, we need to use node to run the JS file directly
+        // since bin/hublaunch is a shell script
+        const distIndexUrl = new URL('../../dist/index.js', import.meta.url);
+        const distIndexPath = fileURLToPath(distIndexUrl);
+        const cmdArgs = [command, ...args].join(' ');
+        logger.blank();
+        // Use node to execute the compiled entry point
+        execSync(`node "${distIndexPath}" ${cmdArgs}`, { stdio: 'inherit' });
+        return true;
+    }
+    catch (error) {
+        logger.error(`Command failed: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+/**
+ * Show help text
+ */
+function showHelp() {
+    console.clear();
+    logger.section('HubLaunch Interactive Mode - Help');
+    logger.blank();
+    logger.info('📋 Main Menu:');
+    logger.info("  • Enter a number to select an issue (e.g., '1' or '1)')");
+    logger.info('  • Type / and search term to filter issues');
+    logger.info('  • Type n for next page, p for previous page');
+    logger.info('  • Type r to refresh issue list');
+    logger.info('  • Type a for admin actions');
+    logger.info('  • Type ? for this help message');
+    logger.info('  • Type q to quit');
+    logger.blank();
+    logger.info('📄 Pagination:');
+    logger.info('  • Default: 10 issues per page');
+    logger.info('  • Set PAGE_SIZE env var to change (e.g., PAGE_SIZE=15)');
+    logger.blank();
+    logger.info('⚙️  Issue Actions Menu:');
+    logger.info('  • i - Open issue in browser');
+    logger.info('  • p - Open plan file');
+    logger.info('  • v - Preview deployment');
+    logger.info('  • d - View code changes (diff)');
+    logger.info('  • r - View PR in browser');
+    logger.info('  • w - Watch tests');
+    logger.info('  • g - Get logs by ID');
+    logger.info('  • c - Checkout PR branch');
+    logger.info('  • m - Merge PR');
+    logger.info('  • s - Set priority');
+    logger.info('  • u - Untrack issue');
+    logger.info('  • o - Respond to Copilot');
+    logger.info('  • x - Close issue & untrack');
+    logger.info('  • l - Latest Copilot comment');
+    logger.info('  • b - Back to issue list');
+    logger.info('  • a - Admin actions');
+    logger.info('  • ? - Help');
+    logger.info('  • q - Quit');
+    logger.blank();
+    logger.info('🔧 Non-Interactive Mode:');
+    logger.info('  hula <command> [options]');
+    logger.info('  Example: hula merge 123');
+    logger.blank();
+}
+/**
+ * Wait for user to press Enter
+ */
+async function waitForEnter() {
+    await inquirer.prompt({
+        type: 'input',
+        name: 'continue',
+        message: 'Press Enter to continue...',
+    });
+}
+/**
+ * Get status emoji
+ */
+function getStatusEmoji(status) {
+    const emojiMap = {
+        [STATUS.UNASSIGNED]: '⚪', // White - Not assigned to anyone
+        [STATUS.INITIAL_WAITING]: '🟡', // Yellow - Copilot assigned, working
+        [STATUS.WAITING]: '🟠', // Orange - Waiting for Copilot response
+        [STATUS.READY]: '🟢', // Green - Ready for review/merge
+    };
+    return emojiMap[status] ?? '⚪';
+}
+/**
+ * Get priority emoji
+ */
+function getPriorityEmoji(priority) {
+    const emojiMap = {
+        Critical: '🔴',
+        High: '🟠',
+        Medium: '🟡',
+        Low: '🟢',
+        Minimal: '⚪',
+    };
+    return emojiMap[priority] ?? '🟡';
+}
+/**
+ * Get deployment status emoji
+ */
+function getDeploymentEmoji(status) {
+    if (!status)
+        return '⏳'; // Default to pending if not set
+    const emojiMap = {
+        pending: '⏳ pending',
+        success: '✅ success',
+        failed: '❌ failed',
+    };
+    return emojiMap[status] ?? '⏳';
+}
+/**
+ * Start background polling for status changes via configurable adapter
+ */
+function startStatusPolling(pollingAdapter, trackingService, config, state) {
+    const pollIntervalMs = Math.max(config.pollIntervalSeconds, MIN_POLL_INTERVAL_SECONDS) * 1000;
+    let consecutiveFailures = 0;
+    const MAX_CONSECUTIVE_FAILURES = 3;
+    let authErrorShown = false;
+    const interval = setInterval(() => {
+        void (async () => {
+            try {
+                state.lastPollingCheckTime = new Date();
+                const timestamp = new Date().toLocaleTimeString();
+                logger.debug(`🔍 [${timestamp}] Polling via ${pollingAdapter.name} adapter...`);
+                // Fetch fresh issues — this is what gets passed to the adapter
+                const currentIssues = await trackingService.getAll();
+                // Delegate change detection to adapter
+                const changes = await pollingAdapter.pollForChanges(currentIssues);
+                if (changes.length > 0) {
+                    logger.debug(`🔍 [${timestamp}] ${changes.length} change(s) detected`);
+                    // Apply tracking status changes
+                    for (const change of changes) {
+                        if (change.field === 'trackingStatus' && change.newValue) {
+                            await trackingService.updateStatus(change.issueNumber, change.newValue);
+                        }
+                        if (change.field === 'deploymentStatus' && change.newValue) {
+                            await trackingService.updateDeploymentStatus(change.issueNumber, change.newValue);
+                        }
+                        if (change.field === 'deploymentStatus' && change.newValue === 'failed') {
+                            await trackingService.markDeploymentNotified(change.issueNumber, new Date().toISOString());
+                        }
+                    }
+                    // Trigger automatic refresh of the TUI
+                    state.shouldAutoRefresh = true;
+                    state.pendingRefresh = true;
+                }
+                consecutiveFailures = 0;
+                authErrorShown = false;
+            }
+            catch (error) {
+                consecutiveFailures++;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const isAuthError = errorMessage.includes('authentication') ||
+                    errorMessage.includes('Unauthorized') ||
+                    errorMessage.includes('HTTP 401') ||
+                    errorMessage.includes('gh auth');
+                const isNetworkError = errorMessage.includes('ENOTFOUND') ||
+                    errorMessage.includes('ETIMEDOUT') ||
+                    errorMessage.includes('ECONNREFUSED') ||
+                    errorMessage.includes('ECONNRESET');
+                logger.debug(`[${new Date().toLocaleTimeString()}] Polling error (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${errorMessage}`);
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && !authErrorShown) {
+                    logger.blank();
+                    if (isAuthError) {
+                        logger.warning(`⚠️  Auto-refresh paused: Authentication failed for ${pollingAdapter.name} adapter`);
+                        logger.info(pollingAdapter.name === 'hula-server'
+                            ? '   Run "hula login" to re-authenticate.'
+                            : '   Run "gh auth login" to re-authenticate.');
+                    }
+                    else if (isNetworkError) {
+                        logger.warning('⚠️  Auto-refresh paused: Unable to connect');
+                        logger.info('   Check your internet connection. Auto-refresh will resume when connection is restored.');
+                    }
+                    else {
+                        logger.warning('⚠️  Auto-refresh temporarily paused due to errors');
+                    }
+                    logger.blank();
+                    authErrorShown = true;
+                }
+                if (consecutiveFailures > MAX_CONSECUTIVE_FAILURES * 2) {
+                    consecutiveFailures = MAX_CONSECUTIVE_FAILURES;
+                }
+            }
+        })();
+    }, pollIntervalMs);
+    return interval;
+}
+/**
+ * Removed: viewJobStatus / viewJobLogs / getJobStatusEmoji
+ *
+ * Per-task job status was removed when the local tracking schema
+ * dropped the `job*` fields as part of the Plan/Project/Task rename.
+ * Use the `hublaunch logs <name>` command instead, which still proxies
+ * the server's `/api/v1/logs/<name>` endpoint.
+ */
+/**
+ * Prompt user for tracking name and view logs
+ */
+async function promptAndViewLogs(config) {
+    const { trackingName } = await inquirer.prompt({
+        type: 'input',
+        name: 'trackingName',
+        message: 'Enter tracking name:',
+        validate: (input) => {
+            if (!input.trim()) {
+                return 'Tracking name is required';
+            }
+            return true;
+        },
+    });
+    await executeLogs(trackingName.trim(), { lines: '100', raw: false }, config);
+}
+//# sourceMappingURL=interactive.js.map